< Summary

Class:Cysharp.Threading.Tasks.Linq.CombineLatest[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult]
Assembly:UniTask.Linq
File(s):C:/Users/ahmet/FunradoCase/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs
Covered lines:0
Uncovered lines:895
Coverable lines:895
Total lines:11372
Line coverage:0% (0 of 895)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:22
Method coverage:0% (0 of 22)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
CombineLatest(...)0%0000%
GetAsyncEnumerator(...)0%0000%
_CombineLatest()0%0000%
_CombineLatest(...)0%0000%
MoveNextAsync()0%0000%
Completed1(...)0%0000%
Completed2(...)0%0000%
Completed3(...)0%0000%
Completed4(...)0%0000%
Completed5(...)0%0000%
Completed6(...)0%0000%
Completed7(...)0%0000%
Completed8(...)0%0000%
Completed9(...)0%0000%
Completed10(...)0%0000%
Completed11(...)0%0000%
Completed12(...)0%0000%
Completed13(...)0%0000%
Completed14(...)0%0000%
TrySetResult()0%0000%
DisposeAsync()0%0000%

File(s)

C:/Users/ahmet/FunradoCase/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs

#LineLine coverage
 1using Cysharp.Threading.Tasks.Internal;
 2using System;
 3using System.Threading;
 4
 5namespace Cysharp.Threading.Tasks.Linq
 6{
 7    public static partial class UniTaskAsyncEnumerable
 8    {
 9        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, TResult>(this IUniTaskAsyncEnumerable<T1> s
 10        {
 11            Error.ThrowArgumentNullException(source1, nameof(source1));
 12            Error.ThrowArgumentNullException(source2, nameof(source2));
 13            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 14
 15            return new CombineLatest<T1, T2, TResult>(source1, source2, resultSelector);
 16        }
 17
 18        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, TResult>(this IUniTaskAsyncEnumerable<T
 19        {
 20            Error.ThrowArgumentNullException(source1, nameof(source1));
 21            Error.ThrowArgumentNullException(source2, nameof(source2));
 22            Error.ThrowArgumentNullException(source3, nameof(source3));
 23            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 24
 25            return new CombineLatest<T1, T2, T3, TResult>(source1, source2, source3, resultSelector);
 26        }
 27
 28        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, TResult>(this IUniTaskAsyncEnumerab
 29        {
 30            Error.ThrowArgumentNullException(source1, nameof(source1));
 31            Error.ThrowArgumentNullException(source2, nameof(source2));
 32            Error.ThrowArgumentNullException(source3, nameof(source3));
 33            Error.ThrowArgumentNullException(source4, nameof(source4));
 34            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 35
 36            return new CombineLatest<T1, T2, T3, T4, TResult>(source1, source2, source3, source4, resultSelector);
 37        }
 38
 39        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, TResult>(this IUniTaskAsyncEnum
 40        {
 41            Error.ThrowArgumentNullException(source1, nameof(source1));
 42            Error.ThrowArgumentNullException(source2, nameof(source2));
 43            Error.ThrowArgumentNullException(source3, nameof(source3));
 44            Error.ThrowArgumentNullException(source4, nameof(source4));
 45            Error.ThrowArgumentNullException(source5, nameof(source5));
 46            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 47
 48            return new CombineLatest<T1, T2, T3, T4, T5, TResult>(source1, source2, source3, source4, source5, resultSel
 49        }
 50
 51        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, TResult>(this IUniTaskAsync
 52        {
 53            Error.ThrowArgumentNullException(source1, nameof(source1));
 54            Error.ThrowArgumentNullException(source2, nameof(source2));
 55            Error.ThrowArgumentNullException(source3, nameof(source3));
 56            Error.ThrowArgumentNullException(source4, nameof(source4));
 57            Error.ThrowArgumentNullException(source5, nameof(source5));
 58            Error.ThrowArgumentNullException(source6, nameof(source6));
 59            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 60
 61            return new CombineLatest<T1, T2, T3, T4, T5, T6, TResult>(source1, source2, source3, source4, source5, sourc
 62        }
 63
 64        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, TResult>(this IUniTaskA
 65        {
 66            Error.ThrowArgumentNullException(source1, nameof(source1));
 67            Error.ThrowArgumentNullException(source2, nameof(source2));
 68            Error.ThrowArgumentNullException(source3, nameof(source3));
 69            Error.ThrowArgumentNullException(source4, nameof(source4));
 70            Error.ThrowArgumentNullException(source5, nameof(source5));
 71            Error.ThrowArgumentNullException(source6, nameof(source6));
 72            Error.ThrowArgumentNullException(source7, nameof(source7));
 73            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 74
 75            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, TResult>(source1, source2, source3, source4, source5, s
 76        }
 77
 78        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this IUniT
 79        {
 80            Error.ThrowArgumentNullException(source1, nameof(source1));
 81            Error.ThrowArgumentNullException(source2, nameof(source2));
 82            Error.ThrowArgumentNullException(source3, nameof(source3));
 83            Error.ThrowArgumentNullException(source4, nameof(source4));
 84            Error.ThrowArgumentNullException(source5, nameof(source5));
 85            Error.ThrowArgumentNullException(source6, nameof(source6));
 86            Error.ThrowArgumentNullException(source7, nameof(source7));
 87            Error.ThrowArgumentNullException(source8, nameof(source8));
 88            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 89
 90            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(source1, source2, source3, source4, source
 91        }
 92
 93        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this I
 94        {
 95            Error.ThrowArgumentNullException(source1, nameof(source1));
 96            Error.ThrowArgumentNullException(source2, nameof(source2));
 97            Error.ThrowArgumentNullException(source3, nameof(source3));
 98            Error.ThrowArgumentNullException(source4, nameof(source4));
 99            Error.ThrowArgumentNullException(source5, nameof(source5));
 100            Error.ThrowArgumentNullException(source6, nameof(source6));
 101            Error.ThrowArgumentNullException(source7, nameof(source7));
 102            Error.ThrowArgumentNullException(source8, nameof(source8));
 103            Error.ThrowArgumentNullException(source9, nameof(source9));
 104            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 105
 106            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(source1, source2, source3, source4, so
 107        }
 108
 109        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(t
 110        {
 111            Error.ThrowArgumentNullException(source1, nameof(source1));
 112            Error.ThrowArgumentNullException(source2, nameof(source2));
 113            Error.ThrowArgumentNullException(source3, nameof(source3));
 114            Error.ThrowArgumentNullException(source4, nameof(source4));
 115            Error.ThrowArgumentNullException(source5, nameof(source5));
 116            Error.ThrowArgumentNullException(source6, nameof(source6));
 117            Error.ThrowArgumentNullException(source7, nameof(source7));
 118            Error.ThrowArgumentNullException(source8, nameof(source8));
 119            Error.ThrowArgumentNullException(source9, nameof(source9));
 120            Error.ThrowArgumentNullException(source10, nameof(source10));
 121            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 122
 123            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(source1, source2, source3, source
 124        }
 125
 126        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResu
 127        {
 128            Error.ThrowArgumentNullException(source1, nameof(source1));
 129            Error.ThrowArgumentNullException(source2, nameof(source2));
 130            Error.ThrowArgumentNullException(source3, nameof(source3));
 131            Error.ThrowArgumentNullException(source4, nameof(source4));
 132            Error.ThrowArgumentNullException(source5, nameof(source5));
 133            Error.ThrowArgumentNullException(source6, nameof(source6));
 134            Error.ThrowArgumentNullException(source7, nameof(source7));
 135            Error.ThrowArgumentNullException(source8, nameof(source8));
 136            Error.ThrowArgumentNullException(source9, nameof(source9));
 137            Error.ThrowArgumentNullException(source10, nameof(source10));
 138            Error.ThrowArgumentNullException(source11, nameof(source11));
 139            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 140
 141            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(source1, source2, source3, s
 142        }
 143
 144        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 
 145        {
 146            Error.ThrowArgumentNullException(source1, nameof(source1));
 147            Error.ThrowArgumentNullException(source2, nameof(source2));
 148            Error.ThrowArgumentNullException(source3, nameof(source3));
 149            Error.ThrowArgumentNullException(source4, nameof(source4));
 150            Error.ThrowArgumentNullException(source5, nameof(source5));
 151            Error.ThrowArgumentNullException(source6, nameof(source6));
 152            Error.ThrowArgumentNullException(source7, nameof(source7));
 153            Error.ThrowArgumentNullException(source8, nameof(source8));
 154            Error.ThrowArgumentNullException(source9, nameof(source9));
 155            Error.ThrowArgumentNullException(source10, nameof(source10));
 156            Error.ThrowArgumentNullException(source11, nameof(source11));
 157            Error.ThrowArgumentNullException(source12, nameof(source12));
 158            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 159
 160            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(source1, source2, sourc
 161        }
 162
 163        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 
 164        {
 165            Error.ThrowArgumentNullException(source1, nameof(source1));
 166            Error.ThrowArgumentNullException(source2, nameof(source2));
 167            Error.ThrowArgumentNullException(source3, nameof(source3));
 168            Error.ThrowArgumentNullException(source4, nameof(source4));
 169            Error.ThrowArgumentNullException(source5, nameof(source5));
 170            Error.ThrowArgumentNullException(source6, nameof(source6));
 171            Error.ThrowArgumentNullException(source7, nameof(source7));
 172            Error.ThrowArgumentNullException(source8, nameof(source8));
 173            Error.ThrowArgumentNullException(source9, nameof(source9));
 174            Error.ThrowArgumentNullException(source10, nameof(source10));
 175            Error.ThrowArgumentNullException(source11, nameof(source11));
 176            Error.ThrowArgumentNullException(source12, nameof(source12));
 177            Error.ThrowArgumentNullException(source13, nameof(source13));
 178            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 179
 180            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(source1, source2, 
 181        }
 182
 183        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 
 184        {
 185            Error.ThrowArgumentNullException(source1, nameof(source1));
 186            Error.ThrowArgumentNullException(source2, nameof(source2));
 187            Error.ThrowArgumentNullException(source3, nameof(source3));
 188            Error.ThrowArgumentNullException(source4, nameof(source4));
 189            Error.ThrowArgumentNullException(source5, nameof(source5));
 190            Error.ThrowArgumentNullException(source6, nameof(source6));
 191            Error.ThrowArgumentNullException(source7, nameof(source7));
 192            Error.ThrowArgumentNullException(source8, nameof(source8));
 193            Error.ThrowArgumentNullException(source9, nameof(source9));
 194            Error.ThrowArgumentNullException(source10, nameof(source10));
 195            Error.ThrowArgumentNullException(source11, nameof(source11));
 196            Error.ThrowArgumentNullException(source12, nameof(source12));
 197            Error.ThrowArgumentNullException(source13, nameof(source13));
 198            Error.ThrowArgumentNullException(source14, nameof(source14));
 199            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 200
 201            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(source1, sour
 202        }
 203
 204        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 
 205        {
 206            Error.ThrowArgumentNullException(source1, nameof(source1));
 207            Error.ThrowArgumentNullException(source2, nameof(source2));
 208            Error.ThrowArgumentNullException(source3, nameof(source3));
 209            Error.ThrowArgumentNullException(source4, nameof(source4));
 210            Error.ThrowArgumentNullException(source5, nameof(source5));
 211            Error.ThrowArgumentNullException(source6, nameof(source6));
 212            Error.ThrowArgumentNullException(source7, nameof(source7));
 213            Error.ThrowArgumentNullException(source8, nameof(source8));
 214            Error.ThrowArgumentNullException(source9, nameof(source9));
 215            Error.ThrowArgumentNullException(source10, nameof(source10));
 216            Error.ThrowArgumentNullException(source11, nameof(source11));
 217            Error.ThrowArgumentNullException(source12, nameof(source12));
 218            Error.ThrowArgumentNullException(source13, nameof(source13));
 219            Error.ThrowArgumentNullException(source14, nameof(source14));
 220            Error.ThrowArgumentNullException(source15, nameof(source15));
 221            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
 222
 223            return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(source1,
 224        }
 225
 226    }
 227
 228    internal class CombineLatest<T1, T2, TResult> : IUniTaskAsyncEnumerable<TResult>
 229    {
 230        readonly IUniTaskAsyncEnumerable<T1> source1;
 231        readonly IUniTaskAsyncEnumerable<T2> source2;
 232
 233        readonly Func<T1, T2, TResult> resultSelector;
 234
 235        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, Func<T1, T2, TRes
 236        {
 237            this.source1 = source1;
 238            this.source2 = source2;
 239
 240            this.resultSelector = resultSelector;
 241        }
 242
 243        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 244        {
 245            return new _CombineLatest(source1, source2, resultSelector, cancellationToken);
 246        }
 247
 248        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 249        {
 250            static readonly Action<object> Completed1Delegate = Completed1;
 251            static readonly Action<object> Completed2Delegate = Completed2;
 252            const int CompleteCount = 2;
 253
 254            readonly IUniTaskAsyncEnumerable<T1> source1;
 255            readonly IUniTaskAsyncEnumerable<T2> source2;
 256
 257            readonly Func<T1, T2, TResult> resultSelector;
 258            CancellationToken cancellationToken;
 259
 260            IUniTaskAsyncEnumerator<T1> enumerator1;
 261            UniTask<bool>.Awaiter awaiter1;
 262            bool hasCurrent1;
 263            bool running1;
 264            T1 current1;
 265
 266            IUniTaskAsyncEnumerator<T2> enumerator2;
 267            UniTask<bool>.Awaiter awaiter2;
 268            bool hasCurrent2;
 269            bool running2;
 270            T2 current2;
 271
 272            int completedCount;
 273            bool syncRunning;
 274            TResult result;
 275
 276            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, Func<T1, T2,
 277            {
 278                this.source1 = source1;
 279                this.source2 = source2;
 280
 281                this.resultSelector = resultSelector;
 282                this.cancellationToken = cancellationToken;
 283                TaskTracker.TrackActiveTask(this, 3);
 284            }
 285
 286            public TResult Current => result;
 287
 288            public UniTask<bool> MoveNextAsync()
 289            {
 290                cancellationToken.ThrowIfCancellationRequested();
 291                if (completedCount == CompleteCount) return CompletedTasks.False;
 292
 293                if (enumerator1 == null)
 294                {
 295                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 296                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 297                }
 298
 299                completionSource.Reset();
 300
 301                AGAIN:
 302                syncRunning = true;
 303                if (!running1)
 304                {
 305                    running1 = true;
 306                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 307                    if (awaiter1.IsCompleted)
 308                    {
 309                        Completed1(this);
 310                    }
 311                    else
 312                    {
 313                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 314                    }
 315                }
 316                if (!running2)
 317                {
 318                    running2 = true;
 319                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 320                    if (awaiter2.IsCompleted)
 321                    {
 322                        Completed2(this);
 323                    }
 324                    else
 325                    {
 326                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 327                    }
 328                }
 329
 330                if (!running1 || !running2)
 331                {
 332                    goto AGAIN;
 333                }
 334                syncRunning = false;
 335
 336                return new UniTask<bool>(this, completionSource.Version);
 337            }
 338
 339            static void Completed1(object state)
 340            {
 341                var self = (_CombineLatest)state;
 342                self.running1 = false;
 343
 344                try
 345                {
 346                    if (self.awaiter1.GetResult())
 347                    {
 348                        self.hasCurrent1 = true;
 349                        self.current1 = self.enumerator1.Current;
 350                        goto SUCCESS;
 351                    }
 352                    else
 353                    {
 354                        self.running1 = true; // as complete, no more call MoveNextAsync.
 355                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 356                        {
 357                            goto COMPLETE;
 358                        }
 359                        return;
 360                    }
 361                }
 362                catch (Exception ex)
 363                {
 364                    self.running1 = true; // as complete, no more call MoveNextAsync.
 365                    self.completedCount = CompleteCount;
 366                    self.completionSource.TrySetException(ex);
 367                    return;
 368                }
 369
 370                SUCCESS:
 371                if (!self.TrySetResult())
 372                {
 373                    if (self.syncRunning) return;
 374                    self.running1 = true; // as complete, no more call MoveNextAsync.
 375                    try
 376                    {
 377                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 378                    }
 379                    catch (Exception ex)
 380                    {
 381                        self.completedCount = CompleteCount;
 382                        self.completionSource.TrySetException(ex);
 383                        return;
 384                    }
 385
 386                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 387                }
 388                return;
 389                COMPLETE:
 390                self.completionSource.TrySetResult(false);
 391                return;
 392            }
 393
 394            static void Completed2(object state)
 395            {
 396                var self = (_CombineLatest)state;
 397                self.running2 = false;
 398
 399                try
 400                {
 401                    if (self.awaiter2.GetResult())
 402                    {
 403                        self.hasCurrent2 = true;
 404                        self.current2 = self.enumerator2.Current;
 405                        goto SUCCESS;
 406                    }
 407                    else
 408                    {
 409                        self.running2 = true; // as complete, no more call MoveNextAsync.
 410                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 411                        {
 412                            goto COMPLETE;
 413                        }
 414                        return;
 415                    }
 416                }
 417                catch (Exception ex)
 418                {
 419                    self.running2 = true; // as complete, no more call MoveNextAsync.
 420                    self.completedCount = CompleteCount;
 421                    self.completionSource.TrySetException(ex);
 422                    return;
 423                }
 424
 425                SUCCESS:
 426                if (!self.TrySetResult())
 427                {
 428                    if (self.syncRunning) return;
 429                    self.running2 = true; // as complete, no more call MoveNextAsync.
 430                    try
 431                    {
 432                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 433                    }
 434                    catch (Exception ex)
 435                    {
 436                        self.completedCount = CompleteCount;
 437                        self.completionSource.TrySetException(ex);
 438                        return;
 439                    }
 440
 441                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 442                }
 443                return;
 444                COMPLETE:
 445                self.completionSource.TrySetResult(false);
 446                return;
 447            }
 448
 449            bool TrySetResult()
 450            {
 451                if (hasCurrent1 && hasCurrent2)
 452                {
 453                    result = resultSelector(current1, current2);
 454                    completionSource.TrySetResult(true);
 455                    return true;
 456                }
 457                else
 458                {
 459                    return false;
 460                }
 461            }
 462
 463            public async UniTask DisposeAsync()
 464            {
 465                TaskTracker.RemoveTracking(this);
 466                if (enumerator1 != null)
 467                {
 468                    await enumerator1.DisposeAsync();
 469                }
 470                if (enumerator2 != null)
 471                {
 472                    await enumerator2.DisposeAsync();
 473                }
 474            }
 475        }
 476    }
 477
 478    internal class CombineLatest<T1, T2, T3, TResult> : IUniTaskAsyncEnumerable<TResult>
 479    {
 480        readonly IUniTaskAsyncEnumerable<T1> source1;
 481        readonly IUniTaskAsyncEnumerable<T2> source2;
 482        readonly IUniTaskAsyncEnumerable<T3> source3;
 483
 484        readonly Func<T1, T2, T3, TResult> resultSelector;
 485
 486        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 487        {
 488            this.source1 = source1;
 489            this.source2 = source2;
 490            this.source3 = source3;
 491
 492            this.resultSelector = resultSelector;
 493        }
 494
 495        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 496        {
 497            return new _CombineLatest(source1, source2, source3, resultSelector, cancellationToken);
 498        }
 499
 500        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 501        {
 502            static readonly Action<object> Completed1Delegate = Completed1;
 503            static readonly Action<object> Completed2Delegate = Completed2;
 504            static readonly Action<object> Completed3Delegate = Completed3;
 505            const int CompleteCount = 3;
 506
 507            readonly IUniTaskAsyncEnumerable<T1> source1;
 508            readonly IUniTaskAsyncEnumerable<T2> source2;
 509            readonly IUniTaskAsyncEnumerable<T3> source3;
 510
 511            readonly Func<T1, T2, T3, TResult> resultSelector;
 512            CancellationToken cancellationToken;
 513
 514            IUniTaskAsyncEnumerator<T1> enumerator1;
 515            UniTask<bool>.Awaiter awaiter1;
 516            bool hasCurrent1;
 517            bool running1;
 518            T1 current1;
 519
 520            IUniTaskAsyncEnumerator<T2> enumerator2;
 521            UniTask<bool>.Awaiter awaiter2;
 522            bool hasCurrent2;
 523            bool running2;
 524            T2 current2;
 525
 526            IUniTaskAsyncEnumerator<T3> enumerator3;
 527            UniTask<bool>.Awaiter awaiter3;
 528            bool hasCurrent3;
 529            bool running3;
 530            T3 current3;
 531
 532            int completedCount;
 533            bool syncRunning;
 534            TResult result;
 535
 536            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 537            {
 538                this.source1 = source1;
 539                this.source2 = source2;
 540                this.source3 = source3;
 541
 542                this.resultSelector = resultSelector;
 543                this.cancellationToken = cancellationToken;
 544                TaskTracker.TrackActiveTask(this, 3);
 545            }
 546
 547            public TResult Current => result;
 548
 549            public UniTask<bool> MoveNextAsync()
 550            {
 551                cancellationToken.ThrowIfCancellationRequested();
 552                if (completedCount == CompleteCount) return CompletedTasks.False;
 553
 554                if (enumerator1 == null)
 555                {
 556                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 557                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 558                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 559                }
 560
 561                completionSource.Reset();
 562
 563                AGAIN:
 564                syncRunning = true;
 565                if (!running1)
 566                {
 567                    running1 = true;
 568                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 569                    if (awaiter1.IsCompleted)
 570                    {
 571                        Completed1(this);
 572                    }
 573                    else
 574                    {
 575                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 576                    }
 577                }
 578                if (!running2)
 579                {
 580                    running2 = true;
 581                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 582                    if (awaiter2.IsCompleted)
 583                    {
 584                        Completed2(this);
 585                    }
 586                    else
 587                    {
 588                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 589                    }
 590                }
 591                if (!running3)
 592                {
 593                    running3 = true;
 594                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 595                    if (awaiter3.IsCompleted)
 596                    {
 597                        Completed3(this);
 598                    }
 599                    else
 600                    {
 601                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 602                    }
 603                }
 604
 605                if (!running1 || !running2 || !running3)
 606                {
 607                    goto AGAIN;
 608                }
 609                syncRunning = false;
 610
 611                return new UniTask<bool>(this, completionSource.Version);
 612            }
 613
 614            static void Completed1(object state)
 615            {
 616                var self = (_CombineLatest)state;
 617                self.running1 = false;
 618
 619                try
 620                {
 621                    if (self.awaiter1.GetResult())
 622                    {
 623                        self.hasCurrent1 = true;
 624                        self.current1 = self.enumerator1.Current;
 625                        goto SUCCESS;
 626                    }
 627                    else
 628                    {
 629                        self.running1 = true; // as complete, no more call MoveNextAsync.
 630                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 631                        {
 632                            goto COMPLETE;
 633                        }
 634                        return;
 635                    }
 636                }
 637                catch (Exception ex)
 638                {
 639                    self.running1 = true; // as complete, no more call MoveNextAsync.
 640                    self.completedCount = CompleteCount;
 641                    self.completionSource.TrySetException(ex);
 642                    return;
 643                }
 644
 645                SUCCESS:
 646                if (!self.TrySetResult())
 647                {
 648                    if (self.syncRunning) return;
 649                    self.running1 = true; // as complete, no more call MoveNextAsync.
 650                    try
 651                    {
 652                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 653                    }
 654                    catch (Exception ex)
 655                    {
 656                        self.completedCount = CompleteCount;
 657                        self.completionSource.TrySetException(ex);
 658                        return;
 659                    }
 660
 661                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 662                }
 663                return;
 664                COMPLETE:
 665                self.completionSource.TrySetResult(false);
 666                return;
 667            }
 668
 669            static void Completed2(object state)
 670            {
 671                var self = (_CombineLatest)state;
 672                self.running2 = false;
 673
 674                try
 675                {
 676                    if (self.awaiter2.GetResult())
 677                    {
 678                        self.hasCurrent2 = true;
 679                        self.current2 = self.enumerator2.Current;
 680                        goto SUCCESS;
 681                    }
 682                    else
 683                    {
 684                        self.running2 = true; // as complete, no more call MoveNextAsync.
 685                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 686                        {
 687                            goto COMPLETE;
 688                        }
 689                        return;
 690                    }
 691                }
 692                catch (Exception ex)
 693                {
 694                    self.running2 = true; // as complete, no more call MoveNextAsync.
 695                    self.completedCount = CompleteCount;
 696                    self.completionSource.TrySetException(ex);
 697                    return;
 698                }
 699
 700                SUCCESS:
 701                if (!self.TrySetResult())
 702                {
 703                    if (self.syncRunning) return;
 704                    self.running2 = true; // as complete, no more call MoveNextAsync.
 705                    try
 706                    {
 707                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 708                    }
 709                    catch (Exception ex)
 710                    {
 711                        self.completedCount = CompleteCount;
 712                        self.completionSource.TrySetException(ex);
 713                        return;
 714                    }
 715
 716                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 717                }
 718                return;
 719                COMPLETE:
 720                self.completionSource.TrySetResult(false);
 721                return;
 722            }
 723
 724            static void Completed3(object state)
 725            {
 726                var self = (_CombineLatest)state;
 727                self.running3 = false;
 728
 729                try
 730                {
 731                    if (self.awaiter3.GetResult())
 732                    {
 733                        self.hasCurrent3 = true;
 734                        self.current3 = self.enumerator3.Current;
 735                        goto SUCCESS;
 736                    }
 737                    else
 738                    {
 739                        self.running3 = true; // as complete, no more call MoveNextAsync.
 740                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 741                        {
 742                            goto COMPLETE;
 743                        }
 744                        return;
 745                    }
 746                }
 747                catch (Exception ex)
 748                {
 749                    self.running3 = true; // as complete, no more call MoveNextAsync.
 750                    self.completedCount = CompleteCount;
 751                    self.completionSource.TrySetException(ex);
 752                    return;
 753                }
 754
 755                SUCCESS:
 756                if (!self.TrySetResult())
 757                {
 758                    if (self.syncRunning) return;
 759                    self.running3 = true; // as complete, no more call MoveNextAsync.
 760                    try
 761                    {
 762                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 763                    }
 764                    catch (Exception ex)
 765                    {
 766                        self.completedCount = CompleteCount;
 767                        self.completionSource.TrySetException(ex);
 768                        return;
 769                    }
 770
 771                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 772                }
 773                return;
 774                COMPLETE:
 775                self.completionSource.TrySetResult(false);
 776                return;
 777            }
 778
 779            bool TrySetResult()
 780            {
 781                if (hasCurrent1 && hasCurrent2 && hasCurrent3)
 782                {
 783                    result = resultSelector(current1, current2, current3);
 784                    completionSource.TrySetResult(true);
 785                    return true;
 786                }
 787                else
 788                {
 789                    return false;
 790                }
 791            }
 792
 793            public async UniTask DisposeAsync()
 794            {
 795                TaskTracker.RemoveTracking(this);
 796                if (enumerator1 != null)
 797                {
 798                    await enumerator1.DisposeAsync();
 799                }
 800                if (enumerator2 != null)
 801                {
 802                    await enumerator2.DisposeAsync();
 803                }
 804                if (enumerator3 != null)
 805                {
 806                    await enumerator3.DisposeAsync();
 807                }
 808            }
 809        }
 810    }
 811
 812    internal class CombineLatest<T1, T2, T3, T4, TResult> : IUniTaskAsyncEnumerable<TResult>
 813    {
 814        readonly IUniTaskAsyncEnumerable<T1> source1;
 815        readonly IUniTaskAsyncEnumerable<T2> source2;
 816        readonly IUniTaskAsyncEnumerable<T3> source3;
 817        readonly IUniTaskAsyncEnumerable<T4> source4;
 818
 819        readonly Func<T1, T2, T3, T4, TResult> resultSelector;
 820
 821        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 822        {
 823            this.source1 = source1;
 824            this.source2 = source2;
 825            this.source3 = source3;
 826            this.source4 = source4;
 827
 828            this.resultSelector = resultSelector;
 829        }
 830
 831        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 832        {
 833            return new _CombineLatest(source1, source2, source3, source4, resultSelector, cancellationToken);
 834        }
 835
 836        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 837        {
 838            static readonly Action<object> Completed1Delegate = Completed1;
 839            static readonly Action<object> Completed2Delegate = Completed2;
 840            static readonly Action<object> Completed3Delegate = Completed3;
 841            static readonly Action<object> Completed4Delegate = Completed4;
 842            const int CompleteCount = 4;
 843
 844            readonly IUniTaskAsyncEnumerable<T1> source1;
 845            readonly IUniTaskAsyncEnumerable<T2> source2;
 846            readonly IUniTaskAsyncEnumerable<T3> source3;
 847            readonly IUniTaskAsyncEnumerable<T4> source4;
 848
 849            readonly Func<T1, T2, T3, T4, TResult> resultSelector;
 850            CancellationToken cancellationToken;
 851
 852            IUniTaskAsyncEnumerator<T1> enumerator1;
 853            UniTask<bool>.Awaiter awaiter1;
 854            bool hasCurrent1;
 855            bool running1;
 856            T1 current1;
 857
 858            IUniTaskAsyncEnumerator<T2> enumerator2;
 859            UniTask<bool>.Awaiter awaiter2;
 860            bool hasCurrent2;
 861            bool running2;
 862            T2 current2;
 863
 864            IUniTaskAsyncEnumerator<T3> enumerator3;
 865            UniTask<bool>.Awaiter awaiter3;
 866            bool hasCurrent3;
 867            bool running3;
 868            T3 current3;
 869
 870            IUniTaskAsyncEnumerator<T4> enumerator4;
 871            UniTask<bool>.Awaiter awaiter4;
 872            bool hasCurrent4;
 873            bool running4;
 874            T4 current4;
 875
 876            int completedCount;
 877            bool syncRunning;
 878            TResult result;
 879
 880            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 881            {
 882                this.source1 = source1;
 883                this.source2 = source2;
 884                this.source3 = source3;
 885                this.source4 = source4;
 886
 887                this.resultSelector = resultSelector;
 888                this.cancellationToken = cancellationToken;
 889                TaskTracker.TrackActiveTask(this, 3);
 890            }
 891
 892            public TResult Current => result;
 893
 894            public UniTask<bool> MoveNextAsync()
 895            {
 896                cancellationToken.ThrowIfCancellationRequested();
 897                if (completedCount == CompleteCount) return CompletedTasks.False;
 898
 899                if (enumerator1 == null)
 900                {
 901                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 902                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 903                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 904                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 905                }
 906
 907                completionSource.Reset();
 908
 909                AGAIN:
 910                syncRunning = true;
 911                if (!running1)
 912                {
 913                    running1 = true;
 914                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 915                    if (awaiter1.IsCompleted)
 916                    {
 917                        Completed1(this);
 918                    }
 919                    else
 920                    {
 921                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 922                    }
 923                }
 924                if (!running2)
 925                {
 926                    running2 = true;
 927                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 928                    if (awaiter2.IsCompleted)
 929                    {
 930                        Completed2(this);
 931                    }
 932                    else
 933                    {
 934                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 935                    }
 936                }
 937                if (!running3)
 938                {
 939                    running3 = true;
 940                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 941                    if (awaiter3.IsCompleted)
 942                    {
 943                        Completed3(this);
 944                    }
 945                    else
 946                    {
 947                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 948                    }
 949                }
 950                if (!running4)
 951                {
 952                    running4 = true;
 953                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 954                    if (awaiter4.IsCompleted)
 955                    {
 956                        Completed4(this);
 957                    }
 958                    else
 959                    {
 960                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 961                    }
 962                }
 963
 964                if (!running1 || !running2 || !running3 || !running4)
 965                {
 966                    goto AGAIN;
 967                }
 968                syncRunning = false;
 969
 970                return new UniTask<bool>(this, completionSource.Version);
 971            }
 972
 973            static void Completed1(object state)
 974            {
 975                var self = (_CombineLatest)state;
 976                self.running1 = false;
 977
 978                try
 979                {
 980                    if (self.awaiter1.GetResult())
 981                    {
 982                        self.hasCurrent1 = true;
 983                        self.current1 = self.enumerator1.Current;
 984                        goto SUCCESS;
 985                    }
 986                    else
 987                    {
 988                        self.running1 = true; // as complete, no more call MoveNextAsync.
 989                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 990                        {
 991                            goto COMPLETE;
 992                        }
 993                        return;
 994                    }
 995                }
 996                catch (Exception ex)
 997                {
 998                    self.running1 = true; // as complete, no more call MoveNextAsync.
 999                    self.completedCount = CompleteCount;
 1000                    self.completionSource.TrySetException(ex);
 1001                    return;
 1002                }
 1003
 1004                SUCCESS:
 1005                if (!self.TrySetResult())
 1006                {
 1007                    if (self.syncRunning) return;
 1008                    self.running1 = true; // as complete, no more call MoveNextAsync.
 1009                    try
 1010                    {
 1011                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 1012                    }
 1013                    catch (Exception ex)
 1014                    {
 1015                        self.completedCount = CompleteCount;
 1016                        self.completionSource.TrySetException(ex);
 1017                        return;
 1018                    }
 1019
 1020                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 1021                }
 1022                return;
 1023                COMPLETE:
 1024                self.completionSource.TrySetResult(false);
 1025                return;
 1026            }
 1027
 1028            static void Completed2(object state)
 1029            {
 1030                var self = (_CombineLatest)state;
 1031                self.running2 = false;
 1032
 1033                try
 1034                {
 1035                    if (self.awaiter2.GetResult())
 1036                    {
 1037                        self.hasCurrent2 = true;
 1038                        self.current2 = self.enumerator2.Current;
 1039                        goto SUCCESS;
 1040                    }
 1041                    else
 1042                    {
 1043                        self.running2 = true; // as complete, no more call MoveNextAsync.
 1044                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1045                        {
 1046                            goto COMPLETE;
 1047                        }
 1048                        return;
 1049                    }
 1050                }
 1051                catch (Exception ex)
 1052                {
 1053                    self.running2 = true; // as complete, no more call MoveNextAsync.
 1054                    self.completedCount = CompleteCount;
 1055                    self.completionSource.TrySetException(ex);
 1056                    return;
 1057                }
 1058
 1059                SUCCESS:
 1060                if (!self.TrySetResult())
 1061                {
 1062                    if (self.syncRunning) return;
 1063                    self.running2 = true; // as complete, no more call MoveNextAsync.
 1064                    try
 1065                    {
 1066                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 1067                    }
 1068                    catch (Exception ex)
 1069                    {
 1070                        self.completedCount = CompleteCount;
 1071                        self.completionSource.TrySetException(ex);
 1072                        return;
 1073                    }
 1074
 1075                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 1076                }
 1077                return;
 1078                COMPLETE:
 1079                self.completionSource.TrySetResult(false);
 1080                return;
 1081            }
 1082
 1083            static void Completed3(object state)
 1084            {
 1085                var self = (_CombineLatest)state;
 1086                self.running3 = false;
 1087
 1088                try
 1089                {
 1090                    if (self.awaiter3.GetResult())
 1091                    {
 1092                        self.hasCurrent3 = true;
 1093                        self.current3 = self.enumerator3.Current;
 1094                        goto SUCCESS;
 1095                    }
 1096                    else
 1097                    {
 1098                        self.running3 = true; // as complete, no more call MoveNextAsync.
 1099                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1100                        {
 1101                            goto COMPLETE;
 1102                        }
 1103                        return;
 1104                    }
 1105                }
 1106                catch (Exception ex)
 1107                {
 1108                    self.running3 = true; // as complete, no more call MoveNextAsync.
 1109                    self.completedCount = CompleteCount;
 1110                    self.completionSource.TrySetException(ex);
 1111                    return;
 1112                }
 1113
 1114                SUCCESS:
 1115                if (!self.TrySetResult())
 1116                {
 1117                    if (self.syncRunning) return;
 1118                    self.running3 = true; // as complete, no more call MoveNextAsync.
 1119                    try
 1120                    {
 1121                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 1122                    }
 1123                    catch (Exception ex)
 1124                    {
 1125                        self.completedCount = CompleteCount;
 1126                        self.completionSource.TrySetException(ex);
 1127                        return;
 1128                    }
 1129
 1130                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 1131                }
 1132                return;
 1133                COMPLETE:
 1134                self.completionSource.TrySetResult(false);
 1135                return;
 1136            }
 1137
 1138            static void Completed4(object state)
 1139            {
 1140                var self = (_CombineLatest)state;
 1141                self.running4 = false;
 1142
 1143                try
 1144                {
 1145                    if (self.awaiter4.GetResult())
 1146                    {
 1147                        self.hasCurrent4 = true;
 1148                        self.current4 = self.enumerator4.Current;
 1149                        goto SUCCESS;
 1150                    }
 1151                    else
 1152                    {
 1153                        self.running4 = true; // as complete, no more call MoveNextAsync.
 1154                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1155                        {
 1156                            goto COMPLETE;
 1157                        }
 1158                        return;
 1159                    }
 1160                }
 1161                catch (Exception ex)
 1162                {
 1163                    self.running4 = true; // as complete, no more call MoveNextAsync.
 1164                    self.completedCount = CompleteCount;
 1165                    self.completionSource.TrySetException(ex);
 1166                    return;
 1167                }
 1168
 1169                SUCCESS:
 1170                if (!self.TrySetResult())
 1171                {
 1172                    if (self.syncRunning) return;
 1173                    self.running4 = true; // as complete, no more call MoveNextAsync.
 1174                    try
 1175                    {
 1176                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 1177                    }
 1178                    catch (Exception ex)
 1179                    {
 1180                        self.completedCount = CompleteCount;
 1181                        self.completionSource.TrySetException(ex);
 1182                        return;
 1183                    }
 1184
 1185                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 1186                }
 1187                return;
 1188                COMPLETE:
 1189                self.completionSource.TrySetResult(false);
 1190                return;
 1191            }
 1192
 1193            bool TrySetResult()
 1194            {
 1195                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4)
 1196                {
 1197                    result = resultSelector(current1, current2, current3, current4);
 1198                    completionSource.TrySetResult(true);
 1199                    return true;
 1200                }
 1201                else
 1202                {
 1203                    return false;
 1204                }
 1205            }
 1206
 1207            public async UniTask DisposeAsync()
 1208            {
 1209                TaskTracker.RemoveTracking(this);
 1210                if (enumerator1 != null)
 1211                {
 1212                    await enumerator1.DisposeAsync();
 1213                }
 1214                if (enumerator2 != null)
 1215                {
 1216                    await enumerator2.DisposeAsync();
 1217                }
 1218                if (enumerator3 != null)
 1219                {
 1220                    await enumerator3.DisposeAsync();
 1221                }
 1222                if (enumerator4 != null)
 1223                {
 1224                    await enumerator4.DisposeAsync();
 1225                }
 1226            }
 1227        }
 1228    }
 1229
 1230    internal class CombineLatest<T1, T2, T3, T4, T5, TResult> : IUniTaskAsyncEnumerable<TResult>
 1231    {
 1232        readonly IUniTaskAsyncEnumerable<T1> source1;
 1233        readonly IUniTaskAsyncEnumerable<T2> source2;
 1234        readonly IUniTaskAsyncEnumerable<T3> source3;
 1235        readonly IUniTaskAsyncEnumerable<T4> source4;
 1236        readonly IUniTaskAsyncEnumerable<T5> source5;
 1237
 1238        readonly Func<T1, T2, T3, T4, T5, TResult> resultSelector;
 1239
 1240        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 1241        {
 1242            this.source1 = source1;
 1243            this.source2 = source2;
 1244            this.source3 = source3;
 1245            this.source4 = source4;
 1246            this.source5 = source5;
 1247
 1248            this.resultSelector = resultSelector;
 1249        }
 1250
 1251        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 1252        {
 1253            return new _CombineLatest(source1, source2, source3, source4, source5, resultSelector, cancellationToken);
 1254        }
 1255
 1256        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 1257        {
 1258            static readonly Action<object> Completed1Delegate = Completed1;
 1259            static readonly Action<object> Completed2Delegate = Completed2;
 1260            static readonly Action<object> Completed3Delegate = Completed3;
 1261            static readonly Action<object> Completed4Delegate = Completed4;
 1262            static readonly Action<object> Completed5Delegate = Completed5;
 1263            const int CompleteCount = 5;
 1264
 1265            readonly IUniTaskAsyncEnumerable<T1> source1;
 1266            readonly IUniTaskAsyncEnumerable<T2> source2;
 1267            readonly IUniTaskAsyncEnumerable<T3> source3;
 1268            readonly IUniTaskAsyncEnumerable<T4> source4;
 1269            readonly IUniTaskAsyncEnumerable<T5> source5;
 1270
 1271            readonly Func<T1, T2, T3, T4, T5, TResult> resultSelector;
 1272            CancellationToken cancellationToken;
 1273
 1274            IUniTaskAsyncEnumerator<T1> enumerator1;
 1275            UniTask<bool>.Awaiter awaiter1;
 1276            bool hasCurrent1;
 1277            bool running1;
 1278            T1 current1;
 1279
 1280            IUniTaskAsyncEnumerator<T2> enumerator2;
 1281            UniTask<bool>.Awaiter awaiter2;
 1282            bool hasCurrent2;
 1283            bool running2;
 1284            T2 current2;
 1285
 1286            IUniTaskAsyncEnumerator<T3> enumerator3;
 1287            UniTask<bool>.Awaiter awaiter3;
 1288            bool hasCurrent3;
 1289            bool running3;
 1290            T3 current3;
 1291
 1292            IUniTaskAsyncEnumerator<T4> enumerator4;
 1293            UniTask<bool>.Awaiter awaiter4;
 1294            bool hasCurrent4;
 1295            bool running4;
 1296            T4 current4;
 1297
 1298            IUniTaskAsyncEnumerator<T5> enumerator5;
 1299            UniTask<bool>.Awaiter awaiter5;
 1300            bool hasCurrent5;
 1301            bool running5;
 1302            T5 current5;
 1303
 1304            int completedCount;
 1305            bool syncRunning;
 1306            TResult result;
 1307
 1308            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 1309            {
 1310                this.source1 = source1;
 1311                this.source2 = source2;
 1312                this.source3 = source3;
 1313                this.source4 = source4;
 1314                this.source5 = source5;
 1315
 1316                this.resultSelector = resultSelector;
 1317                this.cancellationToken = cancellationToken;
 1318                TaskTracker.TrackActiveTask(this, 3);
 1319            }
 1320
 1321            public TResult Current => result;
 1322
 1323            public UniTask<bool> MoveNextAsync()
 1324            {
 1325                cancellationToken.ThrowIfCancellationRequested();
 1326                if (completedCount == CompleteCount) return CompletedTasks.False;
 1327
 1328                if (enumerator1 == null)
 1329                {
 1330                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 1331                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 1332                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 1333                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 1334                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 1335                }
 1336
 1337                completionSource.Reset();
 1338
 1339                AGAIN:
 1340                syncRunning = true;
 1341                if (!running1)
 1342                {
 1343                    running1 = true;
 1344                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 1345                    if (awaiter1.IsCompleted)
 1346                    {
 1347                        Completed1(this);
 1348                    }
 1349                    else
 1350                    {
 1351                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 1352                    }
 1353                }
 1354                if (!running2)
 1355                {
 1356                    running2 = true;
 1357                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 1358                    if (awaiter2.IsCompleted)
 1359                    {
 1360                        Completed2(this);
 1361                    }
 1362                    else
 1363                    {
 1364                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 1365                    }
 1366                }
 1367                if (!running3)
 1368                {
 1369                    running3 = true;
 1370                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 1371                    if (awaiter3.IsCompleted)
 1372                    {
 1373                        Completed3(this);
 1374                    }
 1375                    else
 1376                    {
 1377                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 1378                    }
 1379                }
 1380                if (!running4)
 1381                {
 1382                    running4 = true;
 1383                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 1384                    if (awaiter4.IsCompleted)
 1385                    {
 1386                        Completed4(this);
 1387                    }
 1388                    else
 1389                    {
 1390                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 1391                    }
 1392                }
 1393                if (!running5)
 1394                {
 1395                    running5 = true;
 1396                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 1397                    if (awaiter5.IsCompleted)
 1398                    {
 1399                        Completed5(this);
 1400                    }
 1401                    else
 1402                    {
 1403                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 1404                    }
 1405                }
 1406
 1407                if (!running1 || !running2 || !running3 || !running4 || !running5)
 1408                {
 1409                    goto AGAIN;
 1410                }
 1411                syncRunning = false;
 1412
 1413                return new UniTask<bool>(this, completionSource.Version);
 1414            }
 1415
 1416            static void Completed1(object state)
 1417            {
 1418                var self = (_CombineLatest)state;
 1419                self.running1 = false;
 1420
 1421                try
 1422                {
 1423                    if (self.awaiter1.GetResult())
 1424                    {
 1425                        self.hasCurrent1 = true;
 1426                        self.current1 = self.enumerator1.Current;
 1427                        goto SUCCESS;
 1428                    }
 1429                    else
 1430                    {
 1431                        self.running1 = true; // as complete, no more call MoveNextAsync.
 1432                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1433                        {
 1434                            goto COMPLETE;
 1435                        }
 1436                        return;
 1437                    }
 1438                }
 1439                catch (Exception ex)
 1440                {
 1441                    self.running1 = true; // as complete, no more call MoveNextAsync.
 1442                    self.completedCount = CompleteCount;
 1443                    self.completionSource.TrySetException(ex);
 1444                    return;
 1445                }
 1446
 1447                SUCCESS:
 1448                if (!self.TrySetResult())
 1449                {
 1450                    if (self.syncRunning) return;
 1451                    self.running1 = true; // as complete, no more call MoveNextAsync.
 1452                    try
 1453                    {
 1454                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 1455                    }
 1456                    catch (Exception ex)
 1457                    {
 1458                        self.completedCount = CompleteCount;
 1459                        self.completionSource.TrySetException(ex);
 1460                        return;
 1461                    }
 1462
 1463                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 1464                }
 1465                return;
 1466                COMPLETE:
 1467                self.completionSource.TrySetResult(false);
 1468                return;
 1469            }
 1470
 1471            static void Completed2(object state)
 1472            {
 1473                var self = (_CombineLatest)state;
 1474                self.running2 = false;
 1475
 1476                try
 1477                {
 1478                    if (self.awaiter2.GetResult())
 1479                    {
 1480                        self.hasCurrent2 = true;
 1481                        self.current2 = self.enumerator2.Current;
 1482                        goto SUCCESS;
 1483                    }
 1484                    else
 1485                    {
 1486                        self.running2 = true; // as complete, no more call MoveNextAsync.
 1487                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1488                        {
 1489                            goto COMPLETE;
 1490                        }
 1491                        return;
 1492                    }
 1493                }
 1494                catch (Exception ex)
 1495                {
 1496                    self.running2 = true; // as complete, no more call MoveNextAsync.
 1497                    self.completedCount = CompleteCount;
 1498                    self.completionSource.TrySetException(ex);
 1499                    return;
 1500                }
 1501
 1502                SUCCESS:
 1503                if (!self.TrySetResult())
 1504                {
 1505                    if (self.syncRunning) return;
 1506                    self.running2 = true; // as complete, no more call MoveNextAsync.
 1507                    try
 1508                    {
 1509                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 1510                    }
 1511                    catch (Exception ex)
 1512                    {
 1513                        self.completedCount = CompleteCount;
 1514                        self.completionSource.TrySetException(ex);
 1515                        return;
 1516                    }
 1517
 1518                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 1519                }
 1520                return;
 1521                COMPLETE:
 1522                self.completionSource.TrySetResult(false);
 1523                return;
 1524            }
 1525
 1526            static void Completed3(object state)
 1527            {
 1528                var self = (_CombineLatest)state;
 1529                self.running3 = false;
 1530
 1531                try
 1532                {
 1533                    if (self.awaiter3.GetResult())
 1534                    {
 1535                        self.hasCurrent3 = true;
 1536                        self.current3 = self.enumerator3.Current;
 1537                        goto SUCCESS;
 1538                    }
 1539                    else
 1540                    {
 1541                        self.running3 = true; // as complete, no more call MoveNextAsync.
 1542                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1543                        {
 1544                            goto COMPLETE;
 1545                        }
 1546                        return;
 1547                    }
 1548                }
 1549                catch (Exception ex)
 1550                {
 1551                    self.running3 = true; // as complete, no more call MoveNextAsync.
 1552                    self.completedCount = CompleteCount;
 1553                    self.completionSource.TrySetException(ex);
 1554                    return;
 1555                }
 1556
 1557                SUCCESS:
 1558                if (!self.TrySetResult())
 1559                {
 1560                    if (self.syncRunning) return;
 1561                    self.running3 = true; // as complete, no more call MoveNextAsync.
 1562                    try
 1563                    {
 1564                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 1565                    }
 1566                    catch (Exception ex)
 1567                    {
 1568                        self.completedCount = CompleteCount;
 1569                        self.completionSource.TrySetException(ex);
 1570                        return;
 1571                    }
 1572
 1573                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 1574                }
 1575                return;
 1576                COMPLETE:
 1577                self.completionSource.TrySetResult(false);
 1578                return;
 1579            }
 1580
 1581            static void Completed4(object state)
 1582            {
 1583                var self = (_CombineLatest)state;
 1584                self.running4 = false;
 1585
 1586                try
 1587                {
 1588                    if (self.awaiter4.GetResult())
 1589                    {
 1590                        self.hasCurrent4 = true;
 1591                        self.current4 = self.enumerator4.Current;
 1592                        goto SUCCESS;
 1593                    }
 1594                    else
 1595                    {
 1596                        self.running4 = true; // as complete, no more call MoveNextAsync.
 1597                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1598                        {
 1599                            goto COMPLETE;
 1600                        }
 1601                        return;
 1602                    }
 1603                }
 1604                catch (Exception ex)
 1605                {
 1606                    self.running4 = true; // as complete, no more call MoveNextAsync.
 1607                    self.completedCount = CompleteCount;
 1608                    self.completionSource.TrySetException(ex);
 1609                    return;
 1610                }
 1611
 1612                SUCCESS:
 1613                if (!self.TrySetResult())
 1614                {
 1615                    if (self.syncRunning) return;
 1616                    self.running4 = true; // as complete, no more call MoveNextAsync.
 1617                    try
 1618                    {
 1619                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 1620                    }
 1621                    catch (Exception ex)
 1622                    {
 1623                        self.completedCount = CompleteCount;
 1624                        self.completionSource.TrySetException(ex);
 1625                        return;
 1626                    }
 1627
 1628                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 1629                }
 1630                return;
 1631                COMPLETE:
 1632                self.completionSource.TrySetResult(false);
 1633                return;
 1634            }
 1635
 1636            static void Completed5(object state)
 1637            {
 1638                var self = (_CombineLatest)state;
 1639                self.running5 = false;
 1640
 1641                try
 1642                {
 1643                    if (self.awaiter5.GetResult())
 1644                    {
 1645                        self.hasCurrent5 = true;
 1646                        self.current5 = self.enumerator5.Current;
 1647                        goto SUCCESS;
 1648                    }
 1649                    else
 1650                    {
 1651                        self.running5 = true; // as complete, no more call MoveNextAsync.
 1652                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1653                        {
 1654                            goto COMPLETE;
 1655                        }
 1656                        return;
 1657                    }
 1658                }
 1659                catch (Exception ex)
 1660                {
 1661                    self.running5 = true; // as complete, no more call MoveNextAsync.
 1662                    self.completedCount = CompleteCount;
 1663                    self.completionSource.TrySetException(ex);
 1664                    return;
 1665                }
 1666
 1667                SUCCESS:
 1668                if (!self.TrySetResult())
 1669                {
 1670                    if (self.syncRunning) return;
 1671                    self.running5 = true; // as complete, no more call MoveNextAsync.
 1672                    try
 1673                    {
 1674                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 1675                    }
 1676                    catch (Exception ex)
 1677                    {
 1678                        self.completedCount = CompleteCount;
 1679                        self.completionSource.TrySetException(ex);
 1680                        return;
 1681                    }
 1682
 1683                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 1684                }
 1685                return;
 1686                COMPLETE:
 1687                self.completionSource.TrySetResult(false);
 1688                return;
 1689            }
 1690
 1691            bool TrySetResult()
 1692            {
 1693                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5)
 1694                {
 1695                    result = resultSelector(current1, current2, current3, current4, current5);
 1696                    completionSource.TrySetResult(true);
 1697                    return true;
 1698                }
 1699                else
 1700                {
 1701                    return false;
 1702                }
 1703            }
 1704
 1705            public async UniTask DisposeAsync()
 1706            {
 1707                TaskTracker.RemoveTracking(this);
 1708                if (enumerator1 != null)
 1709                {
 1710                    await enumerator1.DisposeAsync();
 1711                }
 1712                if (enumerator2 != null)
 1713                {
 1714                    await enumerator2.DisposeAsync();
 1715                }
 1716                if (enumerator3 != null)
 1717                {
 1718                    await enumerator3.DisposeAsync();
 1719                }
 1720                if (enumerator4 != null)
 1721                {
 1722                    await enumerator4.DisposeAsync();
 1723                }
 1724                if (enumerator5 != null)
 1725                {
 1726                    await enumerator5.DisposeAsync();
 1727                }
 1728            }
 1729        }
 1730    }
 1731
 1732    internal class CombineLatest<T1, T2, T3, T4, T5, T6, TResult> : IUniTaskAsyncEnumerable<TResult>
 1733    {
 1734        readonly IUniTaskAsyncEnumerable<T1> source1;
 1735        readonly IUniTaskAsyncEnumerable<T2> source2;
 1736        readonly IUniTaskAsyncEnumerable<T3> source3;
 1737        readonly IUniTaskAsyncEnumerable<T4> source4;
 1738        readonly IUniTaskAsyncEnumerable<T5> source5;
 1739        readonly IUniTaskAsyncEnumerable<T6> source6;
 1740
 1741        readonly Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector;
 1742
 1743        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 1744        {
 1745            this.source1 = source1;
 1746            this.source2 = source2;
 1747            this.source3 = source3;
 1748            this.source4 = source4;
 1749            this.source5 = source5;
 1750            this.source6 = source6;
 1751
 1752            this.resultSelector = resultSelector;
 1753        }
 1754
 1755        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 1756        {
 1757            return new _CombineLatest(source1, source2, source3, source4, source5, source6, resultSelector, cancellation
 1758        }
 1759
 1760        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 1761        {
 1762            static readonly Action<object> Completed1Delegate = Completed1;
 1763            static readonly Action<object> Completed2Delegate = Completed2;
 1764            static readonly Action<object> Completed3Delegate = Completed3;
 1765            static readonly Action<object> Completed4Delegate = Completed4;
 1766            static readonly Action<object> Completed5Delegate = Completed5;
 1767            static readonly Action<object> Completed6Delegate = Completed6;
 1768            const int CompleteCount = 6;
 1769
 1770            readonly IUniTaskAsyncEnumerable<T1> source1;
 1771            readonly IUniTaskAsyncEnumerable<T2> source2;
 1772            readonly IUniTaskAsyncEnumerable<T3> source3;
 1773            readonly IUniTaskAsyncEnumerable<T4> source4;
 1774            readonly IUniTaskAsyncEnumerable<T5> source5;
 1775            readonly IUniTaskAsyncEnumerable<T6> source6;
 1776
 1777            readonly Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector;
 1778            CancellationToken cancellationToken;
 1779
 1780            IUniTaskAsyncEnumerator<T1> enumerator1;
 1781            UniTask<bool>.Awaiter awaiter1;
 1782            bool hasCurrent1;
 1783            bool running1;
 1784            T1 current1;
 1785
 1786            IUniTaskAsyncEnumerator<T2> enumerator2;
 1787            UniTask<bool>.Awaiter awaiter2;
 1788            bool hasCurrent2;
 1789            bool running2;
 1790            T2 current2;
 1791
 1792            IUniTaskAsyncEnumerator<T3> enumerator3;
 1793            UniTask<bool>.Awaiter awaiter3;
 1794            bool hasCurrent3;
 1795            bool running3;
 1796            T3 current3;
 1797
 1798            IUniTaskAsyncEnumerator<T4> enumerator4;
 1799            UniTask<bool>.Awaiter awaiter4;
 1800            bool hasCurrent4;
 1801            bool running4;
 1802            T4 current4;
 1803
 1804            IUniTaskAsyncEnumerator<T5> enumerator5;
 1805            UniTask<bool>.Awaiter awaiter5;
 1806            bool hasCurrent5;
 1807            bool running5;
 1808            T5 current5;
 1809
 1810            IUniTaskAsyncEnumerator<T6> enumerator6;
 1811            UniTask<bool>.Awaiter awaiter6;
 1812            bool hasCurrent6;
 1813            bool running6;
 1814            T6 current6;
 1815
 1816            int completedCount;
 1817            bool syncRunning;
 1818            TResult result;
 1819
 1820            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 1821            {
 1822                this.source1 = source1;
 1823                this.source2 = source2;
 1824                this.source3 = source3;
 1825                this.source4 = source4;
 1826                this.source5 = source5;
 1827                this.source6 = source6;
 1828
 1829                this.resultSelector = resultSelector;
 1830                this.cancellationToken = cancellationToken;
 1831                TaskTracker.TrackActiveTask(this, 3);
 1832            }
 1833
 1834            public TResult Current => result;
 1835
 1836            public UniTask<bool> MoveNextAsync()
 1837            {
 1838                cancellationToken.ThrowIfCancellationRequested();
 1839                if (completedCount == CompleteCount) return CompletedTasks.False;
 1840
 1841                if (enumerator1 == null)
 1842                {
 1843                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 1844                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 1845                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 1846                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 1847                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 1848                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 1849                }
 1850
 1851                completionSource.Reset();
 1852
 1853                AGAIN:
 1854                syncRunning = true;
 1855                if (!running1)
 1856                {
 1857                    running1 = true;
 1858                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 1859                    if (awaiter1.IsCompleted)
 1860                    {
 1861                        Completed1(this);
 1862                    }
 1863                    else
 1864                    {
 1865                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 1866                    }
 1867                }
 1868                if (!running2)
 1869                {
 1870                    running2 = true;
 1871                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 1872                    if (awaiter2.IsCompleted)
 1873                    {
 1874                        Completed2(this);
 1875                    }
 1876                    else
 1877                    {
 1878                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 1879                    }
 1880                }
 1881                if (!running3)
 1882                {
 1883                    running3 = true;
 1884                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 1885                    if (awaiter3.IsCompleted)
 1886                    {
 1887                        Completed3(this);
 1888                    }
 1889                    else
 1890                    {
 1891                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 1892                    }
 1893                }
 1894                if (!running4)
 1895                {
 1896                    running4 = true;
 1897                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 1898                    if (awaiter4.IsCompleted)
 1899                    {
 1900                        Completed4(this);
 1901                    }
 1902                    else
 1903                    {
 1904                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 1905                    }
 1906                }
 1907                if (!running5)
 1908                {
 1909                    running5 = true;
 1910                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 1911                    if (awaiter5.IsCompleted)
 1912                    {
 1913                        Completed5(this);
 1914                    }
 1915                    else
 1916                    {
 1917                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 1918                    }
 1919                }
 1920                if (!running6)
 1921                {
 1922                    running6 = true;
 1923                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 1924                    if (awaiter6.IsCompleted)
 1925                    {
 1926                        Completed6(this);
 1927                    }
 1928                    else
 1929                    {
 1930                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 1931                    }
 1932                }
 1933
 1934                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6)
 1935                {
 1936                    goto AGAIN;
 1937                }
 1938                syncRunning = false;
 1939
 1940                return new UniTask<bool>(this, completionSource.Version);
 1941            }
 1942
 1943            static void Completed1(object state)
 1944            {
 1945                var self = (_CombineLatest)state;
 1946                self.running1 = false;
 1947
 1948                try
 1949                {
 1950                    if (self.awaiter1.GetResult())
 1951                    {
 1952                        self.hasCurrent1 = true;
 1953                        self.current1 = self.enumerator1.Current;
 1954                        goto SUCCESS;
 1955                    }
 1956                    else
 1957                    {
 1958                        self.running1 = true; // as complete, no more call MoveNextAsync.
 1959                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 1960                        {
 1961                            goto COMPLETE;
 1962                        }
 1963                        return;
 1964                    }
 1965                }
 1966                catch (Exception ex)
 1967                {
 1968                    self.running1 = true; // as complete, no more call MoveNextAsync.
 1969                    self.completedCount = CompleteCount;
 1970                    self.completionSource.TrySetException(ex);
 1971                    return;
 1972                }
 1973
 1974                SUCCESS:
 1975                if (!self.TrySetResult())
 1976                {
 1977                    if (self.syncRunning) return;
 1978                    self.running1 = true; // as complete, no more call MoveNextAsync.
 1979                    try
 1980                    {
 1981                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 1982                    }
 1983                    catch (Exception ex)
 1984                    {
 1985                        self.completedCount = CompleteCount;
 1986                        self.completionSource.TrySetException(ex);
 1987                        return;
 1988                    }
 1989
 1990                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 1991                }
 1992                return;
 1993                COMPLETE:
 1994                self.completionSource.TrySetResult(false);
 1995                return;
 1996            }
 1997
 1998            static void Completed2(object state)
 1999            {
 2000                var self = (_CombineLatest)state;
 2001                self.running2 = false;
 2002
 2003                try
 2004                {
 2005                    if (self.awaiter2.GetResult())
 2006                    {
 2007                        self.hasCurrent2 = true;
 2008                        self.current2 = self.enumerator2.Current;
 2009                        goto SUCCESS;
 2010                    }
 2011                    else
 2012                    {
 2013                        self.running2 = true; // as complete, no more call MoveNextAsync.
 2014                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2015                        {
 2016                            goto COMPLETE;
 2017                        }
 2018                        return;
 2019                    }
 2020                }
 2021                catch (Exception ex)
 2022                {
 2023                    self.running2 = true; // as complete, no more call MoveNextAsync.
 2024                    self.completedCount = CompleteCount;
 2025                    self.completionSource.TrySetException(ex);
 2026                    return;
 2027                }
 2028
 2029                SUCCESS:
 2030                if (!self.TrySetResult())
 2031                {
 2032                    if (self.syncRunning) return;
 2033                    self.running2 = true; // as complete, no more call MoveNextAsync.
 2034                    try
 2035                    {
 2036                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 2037                    }
 2038                    catch (Exception ex)
 2039                    {
 2040                        self.completedCount = CompleteCount;
 2041                        self.completionSource.TrySetException(ex);
 2042                        return;
 2043                    }
 2044
 2045                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 2046                }
 2047                return;
 2048                COMPLETE:
 2049                self.completionSource.TrySetResult(false);
 2050                return;
 2051            }
 2052
 2053            static void Completed3(object state)
 2054            {
 2055                var self = (_CombineLatest)state;
 2056                self.running3 = false;
 2057
 2058                try
 2059                {
 2060                    if (self.awaiter3.GetResult())
 2061                    {
 2062                        self.hasCurrent3 = true;
 2063                        self.current3 = self.enumerator3.Current;
 2064                        goto SUCCESS;
 2065                    }
 2066                    else
 2067                    {
 2068                        self.running3 = true; // as complete, no more call MoveNextAsync.
 2069                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2070                        {
 2071                            goto COMPLETE;
 2072                        }
 2073                        return;
 2074                    }
 2075                }
 2076                catch (Exception ex)
 2077                {
 2078                    self.running3 = true; // as complete, no more call MoveNextAsync.
 2079                    self.completedCount = CompleteCount;
 2080                    self.completionSource.TrySetException(ex);
 2081                    return;
 2082                }
 2083
 2084                SUCCESS:
 2085                if (!self.TrySetResult())
 2086                {
 2087                    if (self.syncRunning) return;
 2088                    self.running3 = true; // as complete, no more call MoveNextAsync.
 2089                    try
 2090                    {
 2091                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 2092                    }
 2093                    catch (Exception ex)
 2094                    {
 2095                        self.completedCount = CompleteCount;
 2096                        self.completionSource.TrySetException(ex);
 2097                        return;
 2098                    }
 2099
 2100                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 2101                }
 2102                return;
 2103                COMPLETE:
 2104                self.completionSource.TrySetResult(false);
 2105                return;
 2106            }
 2107
 2108            static void Completed4(object state)
 2109            {
 2110                var self = (_CombineLatest)state;
 2111                self.running4 = false;
 2112
 2113                try
 2114                {
 2115                    if (self.awaiter4.GetResult())
 2116                    {
 2117                        self.hasCurrent4 = true;
 2118                        self.current4 = self.enumerator4.Current;
 2119                        goto SUCCESS;
 2120                    }
 2121                    else
 2122                    {
 2123                        self.running4 = true; // as complete, no more call MoveNextAsync.
 2124                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2125                        {
 2126                            goto COMPLETE;
 2127                        }
 2128                        return;
 2129                    }
 2130                }
 2131                catch (Exception ex)
 2132                {
 2133                    self.running4 = true; // as complete, no more call MoveNextAsync.
 2134                    self.completedCount = CompleteCount;
 2135                    self.completionSource.TrySetException(ex);
 2136                    return;
 2137                }
 2138
 2139                SUCCESS:
 2140                if (!self.TrySetResult())
 2141                {
 2142                    if (self.syncRunning) return;
 2143                    self.running4 = true; // as complete, no more call MoveNextAsync.
 2144                    try
 2145                    {
 2146                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 2147                    }
 2148                    catch (Exception ex)
 2149                    {
 2150                        self.completedCount = CompleteCount;
 2151                        self.completionSource.TrySetException(ex);
 2152                        return;
 2153                    }
 2154
 2155                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 2156                }
 2157                return;
 2158                COMPLETE:
 2159                self.completionSource.TrySetResult(false);
 2160                return;
 2161            }
 2162
 2163            static void Completed5(object state)
 2164            {
 2165                var self = (_CombineLatest)state;
 2166                self.running5 = false;
 2167
 2168                try
 2169                {
 2170                    if (self.awaiter5.GetResult())
 2171                    {
 2172                        self.hasCurrent5 = true;
 2173                        self.current5 = self.enumerator5.Current;
 2174                        goto SUCCESS;
 2175                    }
 2176                    else
 2177                    {
 2178                        self.running5 = true; // as complete, no more call MoveNextAsync.
 2179                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2180                        {
 2181                            goto COMPLETE;
 2182                        }
 2183                        return;
 2184                    }
 2185                }
 2186                catch (Exception ex)
 2187                {
 2188                    self.running5 = true; // as complete, no more call MoveNextAsync.
 2189                    self.completedCount = CompleteCount;
 2190                    self.completionSource.TrySetException(ex);
 2191                    return;
 2192                }
 2193
 2194                SUCCESS:
 2195                if (!self.TrySetResult())
 2196                {
 2197                    if (self.syncRunning) return;
 2198                    self.running5 = true; // as complete, no more call MoveNextAsync.
 2199                    try
 2200                    {
 2201                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 2202                    }
 2203                    catch (Exception ex)
 2204                    {
 2205                        self.completedCount = CompleteCount;
 2206                        self.completionSource.TrySetException(ex);
 2207                        return;
 2208                    }
 2209
 2210                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 2211                }
 2212                return;
 2213                COMPLETE:
 2214                self.completionSource.TrySetResult(false);
 2215                return;
 2216            }
 2217
 2218            static void Completed6(object state)
 2219            {
 2220                var self = (_CombineLatest)state;
 2221                self.running6 = false;
 2222
 2223                try
 2224                {
 2225                    if (self.awaiter6.GetResult())
 2226                    {
 2227                        self.hasCurrent6 = true;
 2228                        self.current6 = self.enumerator6.Current;
 2229                        goto SUCCESS;
 2230                    }
 2231                    else
 2232                    {
 2233                        self.running6 = true; // as complete, no more call MoveNextAsync.
 2234                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2235                        {
 2236                            goto COMPLETE;
 2237                        }
 2238                        return;
 2239                    }
 2240                }
 2241                catch (Exception ex)
 2242                {
 2243                    self.running6 = true; // as complete, no more call MoveNextAsync.
 2244                    self.completedCount = CompleteCount;
 2245                    self.completionSource.TrySetException(ex);
 2246                    return;
 2247                }
 2248
 2249                SUCCESS:
 2250                if (!self.TrySetResult())
 2251                {
 2252                    if (self.syncRunning) return;
 2253                    self.running6 = true; // as complete, no more call MoveNextAsync.
 2254                    try
 2255                    {
 2256                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 2257                    }
 2258                    catch (Exception ex)
 2259                    {
 2260                        self.completedCount = CompleteCount;
 2261                        self.completionSource.TrySetException(ex);
 2262                        return;
 2263                    }
 2264
 2265                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 2266                }
 2267                return;
 2268                COMPLETE:
 2269                self.completionSource.TrySetResult(false);
 2270                return;
 2271            }
 2272
 2273            bool TrySetResult()
 2274            {
 2275                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6)
 2276                {
 2277                    result = resultSelector(current1, current2, current3, current4, current5, current6);
 2278                    completionSource.TrySetResult(true);
 2279                    return true;
 2280                }
 2281                else
 2282                {
 2283                    return false;
 2284                }
 2285            }
 2286
 2287            public async UniTask DisposeAsync()
 2288            {
 2289                TaskTracker.RemoveTracking(this);
 2290                if (enumerator1 != null)
 2291                {
 2292                    await enumerator1.DisposeAsync();
 2293                }
 2294                if (enumerator2 != null)
 2295                {
 2296                    await enumerator2.DisposeAsync();
 2297                }
 2298                if (enumerator3 != null)
 2299                {
 2300                    await enumerator3.DisposeAsync();
 2301                }
 2302                if (enumerator4 != null)
 2303                {
 2304                    await enumerator4.DisposeAsync();
 2305                }
 2306                if (enumerator5 != null)
 2307                {
 2308                    await enumerator5.DisposeAsync();
 2309                }
 2310                if (enumerator6 != null)
 2311                {
 2312                    await enumerator6.DisposeAsync();
 2313                }
 2314            }
 2315        }
 2316    }
 2317
 2318    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, TResult> : IUniTaskAsyncEnumerable<TResult>
 2319    {
 2320        readonly IUniTaskAsyncEnumerable<T1> source1;
 2321        readonly IUniTaskAsyncEnumerable<T2> source2;
 2322        readonly IUniTaskAsyncEnumerable<T3> source3;
 2323        readonly IUniTaskAsyncEnumerable<T4> source4;
 2324        readonly IUniTaskAsyncEnumerable<T5> source5;
 2325        readonly IUniTaskAsyncEnumerable<T6> source6;
 2326        readonly IUniTaskAsyncEnumerable<T7> source7;
 2327
 2328        readonly Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector;
 2329
 2330        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 2331        {
 2332            this.source1 = source1;
 2333            this.source2 = source2;
 2334            this.source3 = source3;
 2335            this.source4 = source4;
 2336            this.source5 = source5;
 2337            this.source6 = source6;
 2338            this.source7 = source7;
 2339
 2340            this.resultSelector = resultSelector;
 2341        }
 2342
 2343        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 2344        {
 2345            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, resultSelector, can
 2346        }
 2347
 2348        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 2349        {
 2350            static readonly Action<object> Completed1Delegate = Completed1;
 2351            static readonly Action<object> Completed2Delegate = Completed2;
 2352            static readonly Action<object> Completed3Delegate = Completed3;
 2353            static readonly Action<object> Completed4Delegate = Completed4;
 2354            static readonly Action<object> Completed5Delegate = Completed5;
 2355            static readonly Action<object> Completed6Delegate = Completed6;
 2356            static readonly Action<object> Completed7Delegate = Completed7;
 2357            const int CompleteCount = 7;
 2358
 2359            readonly IUniTaskAsyncEnumerable<T1> source1;
 2360            readonly IUniTaskAsyncEnumerable<T2> source2;
 2361            readonly IUniTaskAsyncEnumerable<T3> source3;
 2362            readonly IUniTaskAsyncEnumerable<T4> source4;
 2363            readonly IUniTaskAsyncEnumerable<T5> source5;
 2364            readonly IUniTaskAsyncEnumerable<T6> source6;
 2365            readonly IUniTaskAsyncEnumerable<T7> source7;
 2366
 2367            readonly Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector;
 2368            CancellationToken cancellationToken;
 2369
 2370            IUniTaskAsyncEnumerator<T1> enumerator1;
 2371            UniTask<bool>.Awaiter awaiter1;
 2372            bool hasCurrent1;
 2373            bool running1;
 2374            T1 current1;
 2375
 2376            IUniTaskAsyncEnumerator<T2> enumerator2;
 2377            UniTask<bool>.Awaiter awaiter2;
 2378            bool hasCurrent2;
 2379            bool running2;
 2380            T2 current2;
 2381
 2382            IUniTaskAsyncEnumerator<T3> enumerator3;
 2383            UniTask<bool>.Awaiter awaiter3;
 2384            bool hasCurrent3;
 2385            bool running3;
 2386            T3 current3;
 2387
 2388            IUniTaskAsyncEnumerator<T4> enumerator4;
 2389            UniTask<bool>.Awaiter awaiter4;
 2390            bool hasCurrent4;
 2391            bool running4;
 2392            T4 current4;
 2393
 2394            IUniTaskAsyncEnumerator<T5> enumerator5;
 2395            UniTask<bool>.Awaiter awaiter5;
 2396            bool hasCurrent5;
 2397            bool running5;
 2398            T5 current5;
 2399
 2400            IUniTaskAsyncEnumerator<T6> enumerator6;
 2401            UniTask<bool>.Awaiter awaiter6;
 2402            bool hasCurrent6;
 2403            bool running6;
 2404            T6 current6;
 2405
 2406            IUniTaskAsyncEnumerator<T7> enumerator7;
 2407            UniTask<bool>.Awaiter awaiter7;
 2408            bool hasCurrent7;
 2409            bool running7;
 2410            T7 current7;
 2411
 2412            int completedCount;
 2413            bool syncRunning;
 2414            TResult result;
 2415
 2416            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 2417            {
 2418                this.source1 = source1;
 2419                this.source2 = source2;
 2420                this.source3 = source3;
 2421                this.source4 = source4;
 2422                this.source5 = source5;
 2423                this.source6 = source6;
 2424                this.source7 = source7;
 2425
 2426                this.resultSelector = resultSelector;
 2427                this.cancellationToken = cancellationToken;
 2428                TaskTracker.TrackActiveTask(this, 3);
 2429            }
 2430
 2431            public TResult Current => result;
 2432
 2433            public UniTask<bool> MoveNextAsync()
 2434            {
 2435                cancellationToken.ThrowIfCancellationRequested();
 2436                if (completedCount == CompleteCount) return CompletedTasks.False;
 2437
 2438                if (enumerator1 == null)
 2439                {
 2440                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 2441                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 2442                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 2443                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 2444                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 2445                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 2446                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 2447                }
 2448
 2449                completionSource.Reset();
 2450
 2451                AGAIN:
 2452                syncRunning = true;
 2453                if (!running1)
 2454                {
 2455                    running1 = true;
 2456                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 2457                    if (awaiter1.IsCompleted)
 2458                    {
 2459                        Completed1(this);
 2460                    }
 2461                    else
 2462                    {
 2463                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 2464                    }
 2465                }
 2466                if (!running2)
 2467                {
 2468                    running2 = true;
 2469                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 2470                    if (awaiter2.IsCompleted)
 2471                    {
 2472                        Completed2(this);
 2473                    }
 2474                    else
 2475                    {
 2476                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 2477                    }
 2478                }
 2479                if (!running3)
 2480                {
 2481                    running3 = true;
 2482                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 2483                    if (awaiter3.IsCompleted)
 2484                    {
 2485                        Completed3(this);
 2486                    }
 2487                    else
 2488                    {
 2489                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 2490                    }
 2491                }
 2492                if (!running4)
 2493                {
 2494                    running4 = true;
 2495                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 2496                    if (awaiter4.IsCompleted)
 2497                    {
 2498                        Completed4(this);
 2499                    }
 2500                    else
 2501                    {
 2502                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 2503                    }
 2504                }
 2505                if (!running5)
 2506                {
 2507                    running5 = true;
 2508                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 2509                    if (awaiter5.IsCompleted)
 2510                    {
 2511                        Completed5(this);
 2512                    }
 2513                    else
 2514                    {
 2515                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 2516                    }
 2517                }
 2518                if (!running6)
 2519                {
 2520                    running6 = true;
 2521                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 2522                    if (awaiter6.IsCompleted)
 2523                    {
 2524                        Completed6(this);
 2525                    }
 2526                    else
 2527                    {
 2528                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 2529                    }
 2530                }
 2531                if (!running7)
 2532                {
 2533                    running7 = true;
 2534                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 2535                    if (awaiter7.IsCompleted)
 2536                    {
 2537                        Completed7(this);
 2538                    }
 2539                    else
 2540                    {
 2541                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 2542                    }
 2543                }
 2544
 2545                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7)
 2546                {
 2547                    goto AGAIN;
 2548                }
 2549                syncRunning = false;
 2550
 2551                return new UniTask<bool>(this, completionSource.Version);
 2552            }
 2553
 2554            static void Completed1(object state)
 2555            {
 2556                var self = (_CombineLatest)state;
 2557                self.running1 = false;
 2558
 2559                try
 2560                {
 2561                    if (self.awaiter1.GetResult())
 2562                    {
 2563                        self.hasCurrent1 = true;
 2564                        self.current1 = self.enumerator1.Current;
 2565                        goto SUCCESS;
 2566                    }
 2567                    else
 2568                    {
 2569                        self.running1 = true; // as complete, no more call MoveNextAsync.
 2570                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2571                        {
 2572                            goto COMPLETE;
 2573                        }
 2574                        return;
 2575                    }
 2576                }
 2577                catch (Exception ex)
 2578                {
 2579                    self.running1 = true; // as complete, no more call MoveNextAsync.
 2580                    self.completedCount = CompleteCount;
 2581                    self.completionSource.TrySetException(ex);
 2582                    return;
 2583                }
 2584
 2585                SUCCESS:
 2586                if (!self.TrySetResult())
 2587                {
 2588                    if (self.syncRunning) return;
 2589                    self.running1 = true; // as complete, no more call MoveNextAsync.
 2590                    try
 2591                    {
 2592                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 2593                    }
 2594                    catch (Exception ex)
 2595                    {
 2596                        self.completedCount = CompleteCount;
 2597                        self.completionSource.TrySetException(ex);
 2598                        return;
 2599                    }
 2600
 2601                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 2602                }
 2603                return;
 2604                COMPLETE:
 2605                self.completionSource.TrySetResult(false);
 2606                return;
 2607            }
 2608
 2609            static void Completed2(object state)
 2610            {
 2611                var self = (_CombineLatest)state;
 2612                self.running2 = false;
 2613
 2614                try
 2615                {
 2616                    if (self.awaiter2.GetResult())
 2617                    {
 2618                        self.hasCurrent2 = true;
 2619                        self.current2 = self.enumerator2.Current;
 2620                        goto SUCCESS;
 2621                    }
 2622                    else
 2623                    {
 2624                        self.running2 = true; // as complete, no more call MoveNextAsync.
 2625                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2626                        {
 2627                            goto COMPLETE;
 2628                        }
 2629                        return;
 2630                    }
 2631                }
 2632                catch (Exception ex)
 2633                {
 2634                    self.running2 = true; // as complete, no more call MoveNextAsync.
 2635                    self.completedCount = CompleteCount;
 2636                    self.completionSource.TrySetException(ex);
 2637                    return;
 2638                }
 2639
 2640                SUCCESS:
 2641                if (!self.TrySetResult())
 2642                {
 2643                    if (self.syncRunning) return;
 2644                    self.running2 = true; // as complete, no more call MoveNextAsync.
 2645                    try
 2646                    {
 2647                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 2648                    }
 2649                    catch (Exception ex)
 2650                    {
 2651                        self.completedCount = CompleteCount;
 2652                        self.completionSource.TrySetException(ex);
 2653                        return;
 2654                    }
 2655
 2656                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 2657                }
 2658                return;
 2659                COMPLETE:
 2660                self.completionSource.TrySetResult(false);
 2661                return;
 2662            }
 2663
 2664            static void Completed3(object state)
 2665            {
 2666                var self = (_CombineLatest)state;
 2667                self.running3 = false;
 2668
 2669                try
 2670                {
 2671                    if (self.awaiter3.GetResult())
 2672                    {
 2673                        self.hasCurrent3 = true;
 2674                        self.current3 = self.enumerator3.Current;
 2675                        goto SUCCESS;
 2676                    }
 2677                    else
 2678                    {
 2679                        self.running3 = true; // as complete, no more call MoveNextAsync.
 2680                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2681                        {
 2682                            goto COMPLETE;
 2683                        }
 2684                        return;
 2685                    }
 2686                }
 2687                catch (Exception ex)
 2688                {
 2689                    self.running3 = true; // as complete, no more call MoveNextAsync.
 2690                    self.completedCount = CompleteCount;
 2691                    self.completionSource.TrySetException(ex);
 2692                    return;
 2693                }
 2694
 2695                SUCCESS:
 2696                if (!self.TrySetResult())
 2697                {
 2698                    if (self.syncRunning) return;
 2699                    self.running3 = true; // as complete, no more call MoveNextAsync.
 2700                    try
 2701                    {
 2702                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 2703                    }
 2704                    catch (Exception ex)
 2705                    {
 2706                        self.completedCount = CompleteCount;
 2707                        self.completionSource.TrySetException(ex);
 2708                        return;
 2709                    }
 2710
 2711                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 2712                }
 2713                return;
 2714                COMPLETE:
 2715                self.completionSource.TrySetResult(false);
 2716                return;
 2717            }
 2718
 2719            static void Completed4(object state)
 2720            {
 2721                var self = (_CombineLatest)state;
 2722                self.running4 = false;
 2723
 2724                try
 2725                {
 2726                    if (self.awaiter4.GetResult())
 2727                    {
 2728                        self.hasCurrent4 = true;
 2729                        self.current4 = self.enumerator4.Current;
 2730                        goto SUCCESS;
 2731                    }
 2732                    else
 2733                    {
 2734                        self.running4 = true; // as complete, no more call MoveNextAsync.
 2735                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2736                        {
 2737                            goto COMPLETE;
 2738                        }
 2739                        return;
 2740                    }
 2741                }
 2742                catch (Exception ex)
 2743                {
 2744                    self.running4 = true; // as complete, no more call MoveNextAsync.
 2745                    self.completedCount = CompleteCount;
 2746                    self.completionSource.TrySetException(ex);
 2747                    return;
 2748                }
 2749
 2750                SUCCESS:
 2751                if (!self.TrySetResult())
 2752                {
 2753                    if (self.syncRunning) return;
 2754                    self.running4 = true; // as complete, no more call MoveNextAsync.
 2755                    try
 2756                    {
 2757                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 2758                    }
 2759                    catch (Exception ex)
 2760                    {
 2761                        self.completedCount = CompleteCount;
 2762                        self.completionSource.TrySetException(ex);
 2763                        return;
 2764                    }
 2765
 2766                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 2767                }
 2768                return;
 2769                COMPLETE:
 2770                self.completionSource.TrySetResult(false);
 2771                return;
 2772            }
 2773
 2774            static void Completed5(object state)
 2775            {
 2776                var self = (_CombineLatest)state;
 2777                self.running5 = false;
 2778
 2779                try
 2780                {
 2781                    if (self.awaiter5.GetResult())
 2782                    {
 2783                        self.hasCurrent5 = true;
 2784                        self.current5 = self.enumerator5.Current;
 2785                        goto SUCCESS;
 2786                    }
 2787                    else
 2788                    {
 2789                        self.running5 = true; // as complete, no more call MoveNextAsync.
 2790                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2791                        {
 2792                            goto COMPLETE;
 2793                        }
 2794                        return;
 2795                    }
 2796                }
 2797                catch (Exception ex)
 2798                {
 2799                    self.running5 = true; // as complete, no more call MoveNextAsync.
 2800                    self.completedCount = CompleteCount;
 2801                    self.completionSource.TrySetException(ex);
 2802                    return;
 2803                }
 2804
 2805                SUCCESS:
 2806                if (!self.TrySetResult())
 2807                {
 2808                    if (self.syncRunning) return;
 2809                    self.running5 = true; // as complete, no more call MoveNextAsync.
 2810                    try
 2811                    {
 2812                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 2813                    }
 2814                    catch (Exception ex)
 2815                    {
 2816                        self.completedCount = CompleteCount;
 2817                        self.completionSource.TrySetException(ex);
 2818                        return;
 2819                    }
 2820
 2821                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 2822                }
 2823                return;
 2824                COMPLETE:
 2825                self.completionSource.TrySetResult(false);
 2826                return;
 2827            }
 2828
 2829            static void Completed6(object state)
 2830            {
 2831                var self = (_CombineLatest)state;
 2832                self.running6 = false;
 2833
 2834                try
 2835                {
 2836                    if (self.awaiter6.GetResult())
 2837                    {
 2838                        self.hasCurrent6 = true;
 2839                        self.current6 = self.enumerator6.Current;
 2840                        goto SUCCESS;
 2841                    }
 2842                    else
 2843                    {
 2844                        self.running6 = true; // as complete, no more call MoveNextAsync.
 2845                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2846                        {
 2847                            goto COMPLETE;
 2848                        }
 2849                        return;
 2850                    }
 2851                }
 2852                catch (Exception ex)
 2853                {
 2854                    self.running6 = true; // as complete, no more call MoveNextAsync.
 2855                    self.completedCount = CompleteCount;
 2856                    self.completionSource.TrySetException(ex);
 2857                    return;
 2858                }
 2859
 2860                SUCCESS:
 2861                if (!self.TrySetResult())
 2862                {
 2863                    if (self.syncRunning) return;
 2864                    self.running6 = true; // as complete, no more call MoveNextAsync.
 2865                    try
 2866                    {
 2867                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 2868                    }
 2869                    catch (Exception ex)
 2870                    {
 2871                        self.completedCount = CompleteCount;
 2872                        self.completionSource.TrySetException(ex);
 2873                        return;
 2874                    }
 2875
 2876                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 2877                }
 2878                return;
 2879                COMPLETE:
 2880                self.completionSource.TrySetResult(false);
 2881                return;
 2882            }
 2883
 2884            static void Completed7(object state)
 2885            {
 2886                var self = (_CombineLatest)state;
 2887                self.running7 = false;
 2888
 2889                try
 2890                {
 2891                    if (self.awaiter7.GetResult())
 2892                    {
 2893                        self.hasCurrent7 = true;
 2894                        self.current7 = self.enumerator7.Current;
 2895                        goto SUCCESS;
 2896                    }
 2897                    else
 2898                    {
 2899                        self.running7 = true; // as complete, no more call MoveNextAsync.
 2900                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 2901                        {
 2902                            goto COMPLETE;
 2903                        }
 2904                        return;
 2905                    }
 2906                }
 2907                catch (Exception ex)
 2908                {
 2909                    self.running7 = true; // as complete, no more call MoveNextAsync.
 2910                    self.completedCount = CompleteCount;
 2911                    self.completionSource.TrySetException(ex);
 2912                    return;
 2913                }
 2914
 2915                SUCCESS:
 2916                if (!self.TrySetResult())
 2917                {
 2918                    if (self.syncRunning) return;
 2919                    self.running7 = true; // as complete, no more call MoveNextAsync.
 2920                    try
 2921                    {
 2922                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 2923                    }
 2924                    catch (Exception ex)
 2925                    {
 2926                        self.completedCount = CompleteCount;
 2927                        self.completionSource.TrySetException(ex);
 2928                        return;
 2929                    }
 2930
 2931                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 2932                }
 2933                return;
 2934                COMPLETE:
 2935                self.completionSource.TrySetResult(false);
 2936                return;
 2937            }
 2938
 2939            bool TrySetResult()
 2940            {
 2941                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 2942                {
 2943                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7);
 2944                    completionSource.TrySetResult(true);
 2945                    return true;
 2946                }
 2947                else
 2948                {
 2949                    return false;
 2950                }
 2951            }
 2952
 2953            public async UniTask DisposeAsync()
 2954            {
 2955                TaskTracker.RemoveTracking(this);
 2956                if (enumerator1 != null)
 2957                {
 2958                    await enumerator1.DisposeAsync();
 2959                }
 2960                if (enumerator2 != null)
 2961                {
 2962                    await enumerator2.DisposeAsync();
 2963                }
 2964                if (enumerator3 != null)
 2965                {
 2966                    await enumerator3.DisposeAsync();
 2967                }
 2968                if (enumerator4 != null)
 2969                {
 2970                    await enumerator4.DisposeAsync();
 2971                }
 2972                if (enumerator5 != null)
 2973                {
 2974                    await enumerator5.DisposeAsync();
 2975                }
 2976                if (enumerator6 != null)
 2977                {
 2978                    await enumerator6.DisposeAsync();
 2979                }
 2980                if (enumerator7 != null)
 2981                {
 2982                    await enumerator7.DisposeAsync();
 2983                }
 2984            }
 2985        }
 2986    }
 2987
 2988    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, TResult> : IUniTaskAsyncEnumerable<TResult>
 2989    {
 2990        readonly IUniTaskAsyncEnumerable<T1> source1;
 2991        readonly IUniTaskAsyncEnumerable<T2> source2;
 2992        readonly IUniTaskAsyncEnumerable<T3> source3;
 2993        readonly IUniTaskAsyncEnumerable<T4> source4;
 2994        readonly IUniTaskAsyncEnumerable<T5> source5;
 2995        readonly IUniTaskAsyncEnumerable<T6> source6;
 2996        readonly IUniTaskAsyncEnumerable<T7> source7;
 2997        readonly IUniTaskAsyncEnumerable<T8> source8;
 2998
 2999        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector;
 3000
 3001        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 3002        {
 3003            this.source1 = source1;
 3004            this.source2 = source2;
 3005            this.source3 = source3;
 3006            this.source4 = source4;
 3007            this.source5 = source5;
 3008            this.source6 = source6;
 3009            this.source7 = source7;
 3010            this.source8 = source8;
 3011
 3012            this.resultSelector = resultSelector;
 3013        }
 3014
 3015        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 3016        {
 3017            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, resultSele
 3018        }
 3019
 3020        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 3021        {
 3022            static readonly Action<object> Completed1Delegate = Completed1;
 3023            static readonly Action<object> Completed2Delegate = Completed2;
 3024            static readonly Action<object> Completed3Delegate = Completed3;
 3025            static readonly Action<object> Completed4Delegate = Completed4;
 3026            static readonly Action<object> Completed5Delegate = Completed5;
 3027            static readonly Action<object> Completed6Delegate = Completed6;
 3028            static readonly Action<object> Completed7Delegate = Completed7;
 3029            static readonly Action<object> Completed8Delegate = Completed8;
 3030            const int CompleteCount = 8;
 3031
 3032            readonly IUniTaskAsyncEnumerable<T1> source1;
 3033            readonly IUniTaskAsyncEnumerable<T2> source2;
 3034            readonly IUniTaskAsyncEnumerable<T3> source3;
 3035            readonly IUniTaskAsyncEnumerable<T4> source4;
 3036            readonly IUniTaskAsyncEnumerable<T5> source5;
 3037            readonly IUniTaskAsyncEnumerable<T6> source6;
 3038            readonly IUniTaskAsyncEnumerable<T7> source7;
 3039            readonly IUniTaskAsyncEnumerable<T8> source8;
 3040
 3041            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector;
 3042            CancellationToken cancellationToken;
 3043
 3044            IUniTaskAsyncEnumerator<T1> enumerator1;
 3045            UniTask<bool>.Awaiter awaiter1;
 3046            bool hasCurrent1;
 3047            bool running1;
 3048            T1 current1;
 3049
 3050            IUniTaskAsyncEnumerator<T2> enumerator2;
 3051            UniTask<bool>.Awaiter awaiter2;
 3052            bool hasCurrent2;
 3053            bool running2;
 3054            T2 current2;
 3055
 3056            IUniTaskAsyncEnumerator<T3> enumerator3;
 3057            UniTask<bool>.Awaiter awaiter3;
 3058            bool hasCurrent3;
 3059            bool running3;
 3060            T3 current3;
 3061
 3062            IUniTaskAsyncEnumerator<T4> enumerator4;
 3063            UniTask<bool>.Awaiter awaiter4;
 3064            bool hasCurrent4;
 3065            bool running4;
 3066            T4 current4;
 3067
 3068            IUniTaskAsyncEnumerator<T5> enumerator5;
 3069            UniTask<bool>.Awaiter awaiter5;
 3070            bool hasCurrent5;
 3071            bool running5;
 3072            T5 current5;
 3073
 3074            IUniTaskAsyncEnumerator<T6> enumerator6;
 3075            UniTask<bool>.Awaiter awaiter6;
 3076            bool hasCurrent6;
 3077            bool running6;
 3078            T6 current6;
 3079
 3080            IUniTaskAsyncEnumerator<T7> enumerator7;
 3081            UniTask<bool>.Awaiter awaiter7;
 3082            bool hasCurrent7;
 3083            bool running7;
 3084            T7 current7;
 3085
 3086            IUniTaskAsyncEnumerator<T8> enumerator8;
 3087            UniTask<bool>.Awaiter awaiter8;
 3088            bool hasCurrent8;
 3089            bool running8;
 3090            T8 current8;
 3091
 3092            int completedCount;
 3093            bool syncRunning;
 3094            TResult result;
 3095
 3096            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 3097            {
 3098                this.source1 = source1;
 3099                this.source2 = source2;
 3100                this.source3 = source3;
 3101                this.source4 = source4;
 3102                this.source5 = source5;
 3103                this.source6 = source6;
 3104                this.source7 = source7;
 3105                this.source8 = source8;
 3106
 3107                this.resultSelector = resultSelector;
 3108                this.cancellationToken = cancellationToken;
 3109                TaskTracker.TrackActiveTask(this, 3);
 3110            }
 3111
 3112            public TResult Current => result;
 3113
 3114            public UniTask<bool> MoveNextAsync()
 3115            {
 3116                cancellationToken.ThrowIfCancellationRequested();
 3117                if (completedCount == CompleteCount) return CompletedTasks.False;
 3118
 3119                if (enumerator1 == null)
 3120                {
 3121                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 3122                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 3123                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 3124                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 3125                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 3126                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 3127                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 3128                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 3129                }
 3130
 3131                completionSource.Reset();
 3132
 3133                AGAIN:
 3134                syncRunning = true;
 3135                if (!running1)
 3136                {
 3137                    running1 = true;
 3138                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 3139                    if (awaiter1.IsCompleted)
 3140                    {
 3141                        Completed1(this);
 3142                    }
 3143                    else
 3144                    {
 3145                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 3146                    }
 3147                }
 3148                if (!running2)
 3149                {
 3150                    running2 = true;
 3151                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 3152                    if (awaiter2.IsCompleted)
 3153                    {
 3154                        Completed2(this);
 3155                    }
 3156                    else
 3157                    {
 3158                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 3159                    }
 3160                }
 3161                if (!running3)
 3162                {
 3163                    running3 = true;
 3164                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 3165                    if (awaiter3.IsCompleted)
 3166                    {
 3167                        Completed3(this);
 3168                    }
 3169                    else
 3170                    {
 3171                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 3172                    }
 3173                }
 3174                if (!running4)
 3175                {
 3176                    running4 = true;
 3177                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 3178                    if (awaiter4.IsCompleted)
 3179                    {
 3180                        Completed4(this);
 3181                    }
 3182                    else
 3183                    {
 3184                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 3185                    }
 3186                }
 3187                if (!running5)
 3188                {
 3189                    running5 = true;
 3190                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 3191                    if (awaiter5.IsCompleted)
 3192                    {
 3193                        Completed5(this);
 3194                    }
 3195                    else
 3196                    {
 3197                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 3198                    }
 3199                }
 3200                if (!running6)
 3201                {
 3202                    running6 = true;
 3203                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 3204                    if (awaiter6.IsCompleted)
 3205                    {
 3206                        Completed6(this);
 3207                    }
 3208                    else
 3209                    {
 3210                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 3211                    }
 3212                }
 3213                if (!running7)
 3214                {
 3215                    running7 = true;
 3216                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 3217                    if (awaiter7.IsCompleted)
 3218                    {
 3219                        Completed7(this);
 3220                    }
 3221                    else
 3222                    {
 3223                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 3224                    }
 3225                }
 3226                if (!running8)
 3227                {
 3228                    running8 = true;
 3229                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 3230                    if (awaiter8.IsCompleted)
 3231                    {
 3232                        Completed8(this);
 3233                    }
 3234                    else
 3235                    {
 3236                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 3237                    }
 3238                }
 3239
 3240                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 3241                {
 3242                    goto AGAIN;
 3243                }
 3244                syncRunning = false;
 3245
 3246                return new UniTask<bool>(this, completionSource.Version);
 3247            }
 3248
 3249            static void Completed1(object state)
 3250            {
 3251                var self = (_CombineLatest)state;
 3252                self.running1 = false;
 3253
 3254                try
 3255                {
 3256                    if (self.awaiter1.GetResult())
 3257                    {
 3258                        self.hasCurrent1 = true;
 3259                        self.current1 = self.enumerator1.Current;
 3260                        goto SUCCESS;
 3261                    }
 3262                    else
 3263                    {
 3264                        self.running1 = true; // as complete, no more call MoveNextAsync.
 3265                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3266                        {
 3267                            goto COMPLETE;
 3268                        }
 3269                        return;
 3270                    }
 3271                }
 3272                catch (Exception ex)
 3273                {
 3274                    self.running1 = true; // as complete, no more call MoveNextAsync.
 3275                    self.completedCount = CompleteCount;
 3276                    self.completionSource.TrySetException(ex);
 3277                    return;
 3278                }
 3279
 3280                SUCCESS:
 3281                if (!self.TrySetResult())
 3282                {
 3283                    if (self.syncRunning) return;
 3284                    self.running1 = true; // as complete, no more call MoveNextAsync.
 3285                    try
 3286                    {
 3287                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 3288                    }
 3289                    catch (Exception ex)
 3290                    {
 3291                        self.completedCount = CompleteCount;
 3292                        self.completionSource.TrySetException(ex);
 3293                        return;
 3294                    }
 3295
 3296                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 3297                }
 3298                return;
 3299                COMPLETE:
 3300                self.completionSource.TrySetResult(false);
 3301                return;
 3302            }
 3303
 3304            static void Completed2(object state)
 3305            {
 3306                var self = (_CombineLatest)state;
 3307                self.running2 = false;
 3308
 3309                try
 3310                {
 3311                    if (self.awaiter2.GetResult())
 3312                    {
 3313                        self.hasCurrent2 = true;
 3314                        self.current2 = self.enumerator2.Current;
 3315                        goto SUCCESS;
 3316                    }
 3317                    else
 3318                    {
 3319                        self.running2 = true; // as complete, no more call MoveNextAsync.
 3320                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3321                        {
 3322                            goto COMPLETE;
 3323                        }
 3324                        return;
 3325                    }
 3326                }
 3327                catch (Exception ex)
 3328                {
 3329                    self.running2 = true; // as complete, no more call MoveNextAsync.
 3330                    self.completedCount = CompleteCount;
 3331                    self.completionSource.TrySetException(ex);
 3332                    return;
 3333                }
 3334
 3335                SUCCESS:
 3336                if (!self.TrySetResult())
 3337                {
 3338                    if (self.syncRunning) return;
 3339                    self.running2 = true; // as complete, no more call MoveNextAsync.
 3340                    try
 3341                    {
 3342                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 3343                    }
 3344                    catch (Exception ex)
 3345                    {
 3346                        self.completedCount = CompleteCount;
 3347                        self.completionSource.TrySetException(ex);
 3348                        return;
 3349                    }
 3350
 3351                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 3352                }
 3353                return;
 3354                COMPLETE:
 3355                self.completionSource.TrySetResult(false);
 3356                return;
 3357            }
 3358
 3359            static void Completed3(object state)
 3360            {
 3361                var self = (_CombineLatest)state;
 3362                self.running3 = false;
 3363
 3364                try
 3365                {
 3366                    if (self.awaiter3.GetResult())
 3367                    {
 3368                        self.hasCurrent3 = true;
 3369                        self.current3 = self.enumerator3.Current;
 3370                        goto SUCCESS;
 3371                    }
 3372                    else
 3373                    {
 3374                        self.running3 = true; // as complete, no more call MoveNextAsync.
 3375                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3376                        {
 3377                            goto COMPLETE;
 3378                        }
 3379                        return;
 3380                    }
 3381                }
 3382                catch (Exception ex)
 3383                {
 3384                    self.running3 = true; // as complete, no more call MoveNextAsync.
 3385                    self.completedCount = CompleteCount;
 3386                    self.completionSource.TrySetException(ex);
 3387                    return;
 3388                }
 3389
 3390                SUCCESS:
 3391                if (!self.TrySetResult())
 3392                {
 3393                    if (self.syncRunning) return;
 3394                    self.running3 = true; // as complete, no more call MoveNextAsync.
 3395                    try
 3396                    {
 3397                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 3398                    }
 3399                    catch (Exception ex)
 3400                    {
 3401                        self.completedCount = CompleteCount;
 3402                        self.completionSource.TrySetException(ex);
 3403                        return;
 3404                    }
 3405
 3406                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 3407                }
 3408                return;
 3409                COMPLETE:
 3410                self.completionSource.TrySetResult(false);
 3411                return;
 3412            }
 3413
 3414            static void Completed4(object state)
 3415            {
 3416                var self = (_CombineLatest)state;
 3417                self.running4 = false;
 3418
 3419                try
 3420                {
 3421                    if (self.awaiter4.GetResult())
 3422                    {
 3423                        self.hasCurrent4 = true;
 3424                        self.current4 = self.enumerator4.Current;
 3425                        goto SUCCESS;
 3426                    }
 3427                    else
 3428                    {
 3429                        self.running4 = true; // as complete, no more call MoveNextAsync.
 3430                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3431                        {
 3432                            goto COMPLETE;
 3433                        }
 3434                        return;
 3435                    }
 3436                }
 3437                catch (Exception ex)
 3438                {
 3439                    self.running4 = true; // as complete, no more call MoveNextAsync.
 3440                    self.completedCount = CompleteCount;
 3441                    self.completionSource.TrySetException(ex);
 3442                    return;
 3443                }
 3444
 3445                SUCCESS:
 3446                if (!self.TrySetResult())
 3447                {
 3448                    if (self.syncRunning) return;
 3449                    self.running4 = true; // as complete, no more call MoveNextAsync.
 3450                    try
 3451                    {
 3452                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 3453                    }
 3454                    catch (Exception ex)
 3455                    {
 3456                        self.completedCount = CompleteCount;
 3457                        self.completionSource.TrySetException(ex);
 3458                        return;
 3459                    }
 3460
 3461                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 3462                }
 3463                return;
 3464                COMPLETE:
 3465                self.completionSource.TrySetResult(false);
 3466                return;
 3467            }
 3468
 3469            static void Completed5(object state)
 3470            {
 3471                var self = (_CombineLatest)state;
 3472                self.running5 = false;
 3473
 3474                try
 3475                {
 3476                    if (self.awaiter5.GetResult())
 3477                    {
 3478                        self.hasCurrent5 = true;
 3479                        self.current5 = self.enumerator5.Current;
 3480                        goto SUCCESS;
 3481                    }
 3482                    else
 3483                    {
 3484                        self.running5 = true; // as complete, no more call MoveNextAsync.
 3485                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3486                        {
 3487                            goto COMPLETE;
 3488                        }
 3489                        return;
 3490                    }
 3491                }
 3492                catch (Exception ex)
 3493                {
 3494                    self.running5 = true; // as complete, no more call MoveNextAsync.
 3495                    self.completedCount = CompleteCount;
 3496                    self.completionSource.TrySetException(ex);
 3497                    return;
 3498                }
 3499
 3500                SUCCESS:
 3501                if (!self.TrySetResult())
 3502                {
 3503                    if (self.syncRunning) return;
 3504                    self.running5 = true; // as complete, no more call MoveNextAsync.
 3505                    try
 3506                    {
 3507                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 3508                    }
 3509                    catch (Exception ex)
 3510                    {
 3511                        self.completedCount = CompleteCount;
 3512                        self.completionSource.TrySetException(ex);
 3513                        return;
 3514                    }
 3515
 3516                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 3517                }
 3518                return;
 3519                COMPLETE:
 3520                self.completionSource.TrySetResult(false);
 3521                return;
 3522            }
 3523
 3524            static void Completed6(object state)
 3525            {
 3526                var self = (_CombineLatest)state;
 3527                self.running6 = false;
 3528
 3529                try
 3530                {
 3531                    if (self.awaiter6.GetResult())
 3532                    {
 3533                        self.hasCurrent6 = true;
 3534                        self.current6 = self.enumerator6.Current;
 3535                        goto SUCCESS;
 3536                    }
 3537                    else
 3538                    {
 3539                        self.running6 = true; // as complete, no more call MoveNextAsync.
 3540                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3541                        {
 3542                            goto COMPLETE;
 3543                        }
 3544                        return;
 3545                    }
 3546                }
 3547                catch (Exception ex)
 3548                {
 3549                    self.running6 = true; // as complete, no more call MoveNextAsync.
 3550                    self.completedCount = CompleteCount;
 3551                    self.completionSource.TrySetException(ex);
 3552                    return;
 3553                }
 3554
 3555                SUCCESS:
 3556                if (!self.TrySetResult())
 3557                {
 3558                    if (self.syncRunning) return;
 3559                    self.running6 = true; // as complete, no more call MoveNextAsync.
 3560                    try
 3561                    {
 3562                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 3563                    }
 3564                    catch (Exception ex)
 3565                    {
 3566                        self.completedCount = CompleteCount;
 3567                        self.completionSource.TrySetException(ex);
 3568                        return;
 3569                    }
 3570
 3571                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 3572                }
 3573                return;
 3574                COMPLETE:
 3575                self.completionSource.TrySetResult(false);
 3576                return;
 3577            }
 3578
 3579            static void Completed7(object state)
 3580            {
 3581                var self = (_CombineLatest)state;
 3582                self.running7 = false;
 3583
 3584                try
 3585                {
 3586                    if (self.awaiter7.GetResult())
 3587                    {
 3588                        self.hasCurrent7 = true;
 3589                        self.current7 = self.enumerator7.Current;
 3590                        goto SUCCESS;
 3591                    }
 3592                    else
 3593                    {
 3594                        self.running7 = true; // as complete, no more call MoveNextAsync.
 3595                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3596                        {
 3597                            goto COMPLETE;
 3598                        }
 3599                        return;
 3600                    }
 3601                }
 3602                catch (Exception ex)
 3603                {
 3604                    self.running7 = true; // as complete, no more call MoveNextAsync.
 3605                    self.completedCount = CompleteCount;
 3606                    self.completionSource.TrySetException(ex);
 3607                    return;
 3608                }
 3609
 3610                SUCCESS:
 3611                if (!self.TrySetResult())
 3612                {
 3613                    if (self.syncRunning) return;
 3614                    self.running7 = true; // as complete, no more call MoveNextAsync.
 3615                    try
 3616                    {
 3617                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 3618                    }
 3619                    catch (Exception ex)
 3620                    {
 3621                        self.completedCount = CompleteCount;
 3622                        self.completionSource.TrySetException(ex);
 3623                        return;
 3624                    }
 3625
 3626                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 3627                }
 3628                return;
 3629                COMPLETE:
 3630                self.completionSource.TrySetResult(false);
 3631                return;
 3632            }
 3633
 3634            static void Completed8(object state)
 3635            {
 3636                var self = (_CombineLatest)state;
 3637                self.running8 = false;
 3638
 3639                try
 3640                {
 3641                    if (self.awaiter8.GetResult())
 3642                    {
 3643                        self.hasCurrent8 = true;
 3644                        self.current8 = self.enumerator8.Current;
 3645                        goto SUCCESS;
 3646                    }
 3647                    else
 3648                    {
 3649                        self.running8 = true; // as complete, no more call MoveNextAsync.
 3650                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 3651                        {
 3652                            goto COMPLETE;
 3653                        }
 3654                        return;
 3655                    }
 3656                }
 3657                catch (Exception ex)
 3658                {
 3659                    self.running8 = true; // as complete, no more call MoveNextAsync.
 3660                    self.completedCount = CompleteCount;
 3661                    self.completionSource.TrySetException(ex);
 3662                    return;
 3663                }
 3664
 3665                SUCCESS:
 3666                if (!self.TrySetResult())
 3667                {
 3668                    if (self.syncRunning) return;
 3669                    self.running8 = true; // as complete, no more call MoveNextAsync.
 3670                    try
 3671                    {
 3672                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 3673                    }
 3674                    catch (Exception ex)
 3675                    {
 3676                        self.completedCount = CompleteCount;
 3677                        self.completionSource.TrySetException(ex);
 3678                        return;
 3679                    }
 3680
 3681                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 3682                }
 3683                return;
 3684                COMPLETE:
 3685                self.completionSource.TrySetResult(false);
 3686                return;
 3687            }
 3688
 3689            bool TrySetResult()
 3690            {
 3691                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 3692                {
 3693                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 3694                    completionSource.TrySetResult(true);
 3695                    return true;
 3696                }
 3697                else
 3698                {
 3699                    return false;
 3700                }
 3701            }
 3702
 3703            public async UniTask DisposeAsync()
 3704            {
 3705                TaskTracker.RemoveTracking(this);
 3706                if (enumerator1 != null)
 3707                {
 3708                    await enumerator1.DisposeAsync();
 3709                }
 3710                if (enumerator2 != null)
 3711                {
 3712                    await enumerator2.DisposeAsync();
 3713                }
 3714                if (enumerator3 != null)
 3715                {
 3716                    await enumerator3.DisposeAsync();
 3717                }
 3718                if (enumerator4 != null)
 3719                {
 3720                    await enumerator4.DisposeAsync();
 3721                }
 3722                if (enumerator5 != null)
 3723                {
 3724                    await enumerator5.DisposeAsync();
 3725                }
 3726                if (enumerator6 != null)
 3727                {
 3728                    await enumerator6.DisposeAsync();
 3729                }
 3730                if (enumerator7 != null)
 3731                {
 3732                    await enumerator7.DisposeAsync();
 3733                }
 3734                if (enumerator8 != null)
 3735                {
 3736                    await enumerator8.DisposeAsync();
 3737                }
 3738            }
 3739        }
 3740    }
 3741
 3742    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> : IUniTaskAsyncEnumerable<TResult>
 3743    {
 3744        readonly IUniTaskAsyncEnumerable<T1> source1;
 3745        readonly IUniTaskAsyncEnumerable<T2> source2;
 3746        readonly IUniTaskAsyncEnumerable<T3> source3;
 3747        readonly IUniTaskAsyncEnumerable<T4> source4;
 3748        readonly IUniTaskAsyncEnumerable<T5> source5;
 3749        readonly IUniTaskAsyncEnumerable<T6> source6;
 3750        readonly IUniTaskAsyncEnumerable<T7> source7;
 3751        readonly IUniTaskAsyncEnumerable<T8> source8;
 3752        readonly IUniTaskAsyncEnumerable<T9> source9;
 3753
 3754        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector;
 3755
 3756        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 3757        {
 3758            this.source1 = source1;
 3759            this.source2 = source2;
 3760            this.source3 = source3;
 3761            this.source4 = source4;
 3762            this.source5 = source5;
 3763            this.source6 = source6;
 3764            this.source7 = source7;
 3765            this.source8 = source8;
 3766            this.source9 = source9;
 3767
 3768            this.resultSelector = resultSelector;
 3769        }
 3770
 3771        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 3772        {
 3773            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, r
 3774        }
 3775
 3776        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 3777        {
 3778            static readonly Action<object> Completed1Delegate = Completed1;
 3779            static readonly Action<object> Completed2Delegate = Completed2;
 3780            static readonly Action<object> Completed3Delegate = Completed3;
 3781            static readonly Action<object> Completed4Delegate = Completed4;
 3782            static readonly Action<object> Completed5Delegate = Completed5;
 3783            static readonly Action<object> Completed6Delegate = Completed6;
 3784            static readonly Action<object> Completed7Delegate = Completed7;
 3785            static readonly Action<object> Completed8Delegate = Completed8;
 3786            static readonly Action<object> Completed9Delegate = Completed9;
 3787            const int CompleteCount = 9;
 3788
 3789            readonly IUniTaskAsyncEnumerable<T1> source1;
 3790            readonly IUniTaskAsyncEnumerable<T2> source2;
 3791            readonly IUniTaskAsyncEnumerable<T3> source3;
 3792            readonly IUniTaskAsyncEnumerable<T4> source4;
 3793            readonly IUniTaskAsyncEnumerable<T5> source5;
 3794            readonly IUniTaskAsyncEnumerable<T6> source6;
 3795            readonly IUniTaskAsyncEnumerable<T7> source7;
 3796            readonly IUniTaskAsyncEnumerable<T8> source8;
 3797            readonly IUniTaskAsyncEnumerable<T9> source9;
 3798
 3799            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector;
 3800            CancellationToken cancellationToken;
 3801
 3802            IUniTaskAsyncEnumerator<T1> enumerator1;
 3803            UniTask<bool>.Awaiter awaiter1;
 3804            bool hasCurrent1;
 3805            bool running1;
 3806            T1 current1;
 3807
 3808            IUniTaskAsyncEnumerator<T2> enumerator2;
 3809            UniTask<bool>.Awaiter awaiter2;
 3810            bool hasCurrent2;
 3811            bool running2;
 3812            T2 current2;
 3813
 3814            IUniTaskAsyncEnumerator<T3> enumerator3;
 3815            UniTask<bool>.Awaiter awaiter3;
 3816            bool hasCurrent3;
 3817            bool running3;
 3818            T3 current3;
 3819
 3820            IUniTaskAsyncEnumerator<T4> enumerator4;
 3821            UniTask<bool>.Awaiter awaiter4;
 3822            bool hasCurrent4;
 3823            bool running4;
 3824            T4 current4;
 3825
 3826            IUniTaskAsyncEnumerator<T5> enumerator5;
 3827            UniTask<bool>.Awaiter awaiter5;
 3828            bool hasCurrent5;
 3829            bool running5;
 3830            T5 current5;
 3831
 3832            IUniTaskAsyncEnumerator<T6> enumerator6;
 3833            UniTask<bool>.Awaiter awaiter6;
 3834            bool hasCurrent6;
 3835            bool running6;
 3836            T6 current6;
 3837
 3838            IUniTaskAsyncEnumerator<T7> enumerator7;
 3839            UniTask<bool>.Awaiter awaiter7;
 3840            bool hasCurrent7;
 3841            bool running7;
 3842            T7 current7;
 3843
 3844            IUniTaskAsyncEnumerator<T8> enumerator8;
 3845            UniTask<bool>.Awaiter awaiter8;
 3846            bool hasCurrent8;
 3847            bool running8;
 3848            T8 current8;
 3849
 3850            IUniTaskAsyncEnumerator<T9> enumerator9;
 3851            UniTask<bool>.Awaiter awaiter9;
 3852            bool hasCurrent9;
 3853            bool running9;
 3854            T9 current9;
 3855
 3856            int completedCount;
 3857            bool syncRunning;
 3858            TResult result;
 3859
 3860            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 3861            {
 3862                this.source1 = source1;
 3863                this.source2 = source2;
 3864                this.source3 = source3;
 3865                this.source4 = source4;
 3866                this.source5 = source5;
 3867                this.source6 = source6;
 3868                this.source7 = source7;
 3869                this.source8 = source8;
 3870                this.source9 = source9;
 3871
 3872                this.resultSelector = resultSelector;
 3873                this.cancellationToken = cancellationToken;
 3874                TaskTracker.TrackActiveTask(this, 3);
 3875            }
 3876
 3877            public TResult Current => result;
 3878
 3879            public UniTask<bool> MoveNextAsync()
 3880            {
 3881                cancellationToken.ThrowIfCancellationRequested();
 3882                if (completedCount == CompleteCount) return CompletedTasks.False;
 3883
 3884                if (enumerator1 == null)
 3885                {
 3886                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 3887                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 3888                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 3889                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 3890                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 3891                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 3892                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 3893                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 3894                    enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
 3895                }
 3896
 3897                completionSource.Reset();
 3898
 3899                AGAIN:
 3900                syncRunning = true;
 3901                if (!running1)
 3902                {
 3903                    running1 = true;
 3904                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 3905                    if (awaiter1.IsCompleted)
 3906                    {
 3907                        Completed1(this);
 3908                    }
 3909                    else
 3910                    {
 3911                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 3912                    }
 3913                }
 3914                if (!running2)
 3915                {
 3916                    running2 = true;
 3917                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 3918                    if (awaiter2.IsCompleted)
 3919                    {
 3920                        Completed2(this);
 3921                    }
 3922                    else
 3923                    {
 3924                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 3925                    }
 3926                }
 3927                if (!running3)
 3928                {
 3929                    running3 = true;
 3930                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 3931                    if (awaiter3.IsCompleted)
 3932                    {
 3933                        Completed3(this);
 3934                    }
 3935                    else
 3936                    {
 3937                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 3938                    }
 3939                }
 3940                if (!running4)
 3941                {
 3942                    running4 = true;
 3943                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 3944                    if (awaiter4.IsCompleted)
 3945                    {
 3946                        Completed4(this);
 3947                    }
 3948                    else
 3949                    {
 3950                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 3951                    }
 3952                }
 3953                if (!running5)
 3954                {
 3955                    running5 = true;
 3956                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 3957                    if (awaiter5.IsCompleted)
 3958                    {
 3959                        Completed5(this);
 3960                    }
 3961                    else
 3962                    {
 3963                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 3964                    }
 3965                }
 3966                if (!running6)
 3967                {
 3968                    running6 = true;
 3969                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 3970                    if (awaiter6.IsCompleted)
 3971                    {
 3972                        Completed6(this);
 3973                    }
 3974                    else
 3975                    {
 3976                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 3977                    }
 3978                }
 3979                if (!running7)
 3980                {
 3981                    running7 = true;
 3982                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 3983                    if (awaiter7.IsCompleted)
 3984                    {
 3985                        Completed7(this);
 3986                    }
 3987                    else
 3988                    {
 3989                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 3990                    }
 3991                }
 3992                if (!running8)
 3993                {
 3994                    running8 = true;
 3995                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 3996                    if (awaiter8.IsCompleted)
 3997                    {
 3998                        Completed8(this);
 3999                    }
 4000                    else
 4001                    {
 4002                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 4003                    }
 4004                }
 4005                if (!running9)
 4006                {
 4007                    running9 = true;
 4008                    awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
 4009                    if (awaiter9.IsCompleted)
 4010                    {
 4011                        Completed9(this);
 4012                    }
 4013                    else
 4014                    {
 4015                        awaiter9.SourceOnCompleted(Completed9Delegate, this);
 4016                    }
 4017                }
 4018
 4019                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 4020                {
 4021                    goto AGAIN;
 4022                }
 4023                syncRunning = false;
 4024
 4025                return new UniTask<bool>(this, completionSource.Version);
 4026            }
 4027
 4028            static void Completed1(object state)
 4029            {
 4030                var self = (_CombineLatest)state;
 4031                self.running1 = false;
 4032
 4033                try
 4034                {
 4035                    if (self.awaiter1.GetResult())
 4036                    {
 4037                        self.hasCurrent1 = true;
 4038                        self.current1 = self.enumerator1.Current;
 4039                        goto SUCCESS;
 4040                    }
 4041                    else
 4042                    {
 4043                        self.running1 = true; // as complete, no more call MoveNextAsync.
 4044                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4045                        {
 4046                            goto COMPLETE;
 4047                        }
 4048                        return;
 4049                    }
 4050                }
 4051                catch (Exception ex)
 4052                {
 4053                    self.running1 = true; // as complete, no more call MoveNextAsync.
 4054                    self.completedCount = CompleteCount;
 4055                    self.completionSource.TrySetException(ex);
 4056                    return;
 4057                }
 4058
 4059                SUCCESS:
 4060                if (!self.TrySetResult())
 4061                {
 4062                    if (self.syncRunning) return;
 4063                    self.running1 = true; // as complete, no more call MoveNextAsync.
 4064                    try
 4065                    {
 4066                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 4067                    }
 4068                    catch (Exception ex)
 4069                    {
 4070                        self.completedCount = CompleteCount;
 4071                        self.completionSource.TrySetException(ex);
 4072                        return;
 4073                    }
 4074
 4075                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 4076                }
 4077                return;
 4078                COMPLETE:
 4079                self.completionSource.TrySetResult(false);
 4080                return;
 4081            }
 4082
 4083            static void Completed2(object state)
 4084            {
 4085                var self = (_CombineLatest)state;
 4086                self.running2 = false;
 4087
 4088                try
 4089                {
 4090                    if (self.awaiter2.GetResult())
 4091                    {
 4092                        self.hasCurrent2 = true;
 4093                        self.current2 = self.enumerator2.Current;
 4094                        goto SUCCESS;
 4095                    }
 4096                    else
 4097                    {
 4098                        self.running2 = true; // as complete, no more call MoveNextAsync.
 4099                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4100                        {
 4101                            goto COMPLETE;
 4102                        }
 4103                        return;
 4104                    }
 4105                }
 4106                catch (Exception ex)
 4107                {
 4108                    self.running2 = true; // as complete, no more call MoveNextAsync.
 4109                    self.completedCount = CompleteCount;
 4110                    self.completionSource.TrySetException(ex);
 4111                    return;
 4112                }
 4113
 4114                SUCCESS:
 4115                if (!self.TrySetResult())
 4116                {
 4117                    if (self.syncRunning) return;
 4118                    self.running2 = true; // as complete, no more call MoveNextAsync.
 4119                    try
 4120                    {
 4121                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 4122                    }
 4123                    catch (Exception ex)
 4124                    {
 4125                        self.completedCount = CompleteCount;
 4126                        self.completionSource.TrySetException(ex);
 4127                        return;
 4128                    }
 4129
 4130                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 4131                }
 4132                return;
 4133                COMPLETE:
 4134                self.completionSource.TrySetResult(false);
 4135                return;
 4136            }
 4137
 4138            static void Completed3(object state)
 4139            {
 4140                var self = (_CombineLatest)state;
 4141                self.running3 = false;
 4142
 4143                try
 4144                {
 4145                    if (self.awaiter3.GetResult())
 4146                    {
 4147                        self.hasCurrent3 = true;
 4148                        self.current3 = self.enumerator3.Current;
 4149                        goto SUCCESS;
 4150                    }
 4151                    else
 4152                    {
 4153                        self.running3 = true; // as complete, no more call MoveNextAsync.
 4154                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4155                        {
 4156                            goto COMPLETE;
 4157                        }
 4158                        return;
 4159                    }
 4160                }
 4161                catch (Exception ex)
 4162                {
 4163                    self.running3 = true; // as complete, no more call MoveNextAsync.
 4164                    self.completedCount = CompleteCount;
 4165                    self.completionSource.TrySetException(ex);
 4166                    return;
 4167                }
 4168
 4169                SUCCESS:
 4170                if (!self.TrySetResult())
 4171                {
 4172                    if (self.syncRunning) return;
 4173                    self.running3 = true; // as complete, no more call MoveNextAsync.
 4174                    try
 4175                    {
 4176                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 4177                    }
 4178                    catch (Exception ex)
 4179                    {
 4180                        self.completedCount = CompleteCount;
 4181                        self.completionSource.TrySetException(ex);
 4182                        return;
 4183                    }
 4184
 4185                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 4186                }
 4187                return;
 4188                COMPLETE:
 4189                self.completionSource.TrySetResult(false);
 4190                return;
 4191            }
 4192
 4193            static void Completed4(object state)
 4194            {
 4195                var self = (_CombineLatest)state;
 4196                self.running4 = false;
 4197
 4198                try
 4199                {
 4200                    if (self.awaiter4.GetResult())
 4201                    {
 4202                        self.hasCurrent4 = true;
 4203                        self.current4 = self.enumerator4.Current;
 4204                        goto SUCCESS;
 4205                    }
 4206                    else
 4207                    {
 4208                        self.running4 = true; // as complete, no more call MoveNextAsync.
 4209                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4210                        {
 4211                            goto COMPLETE;
 4212                        }
 4213                        return;
 4214                    }
 4215                }
 4216                catch (Exception ex)
 4217                {
 4218                    self.running4 = true; // as complete, no more call MoveNextAsync.
 4219                    self.completedCount = CompleteCount;
 4220                    self.completionSource.TrySetException(ex);
 4221                    return;
 4222                }
 4223
 4224                SUCCESS:
 4225                if (!self.TrySetResult())
 4226                {
 4227                    if (self.syncRunning) return;
 4228                    self.running4 = true; // as complete, no more call MoveNextAsync.
 4229                    try
 4230                    {
 4231                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 4232                    }
 4233                    catch (Exception ex)
 4234                    {
 4235                        self.completedCount = CompleteCount;
 4236                        self.completionSource.TrySetException(ex);
 4237                        return;
 4238                    }
 4239
 4240                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 4241                }
 4242                return;
 4243                COMPLETE:
 4244                self.completionSource.TrySetResult(false);
 4245                return;
 4246            }
 4247
 4248            static void Completed5(object state)
 4249            {
 4250                var self = (_CombineLatest)state;
 4251                self.running5 = false;
 4252
 4253                try
 4254                {
 4255                    if (self.awaiter5.GetResult())
 4256                    {
 4257                        self.hasCurrent5 = true;
 4258                        self.current5 = self.enumerator5.Current;
 4259                        goto SUCCESS;
 4260                    }
 4261                    else
 4262                    {
 4263                        self.running5 = true; // as complete, no more call MoveNextAsync.
 4264                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4265                        {
 4266                            goto COMPLETE;
 4267                        }
 4268                        return;
 4269                    }
 4270                }
 4271                catch (Exception ex)
 4272                {
 4273                    self.running5 = true; // as complete, no more call MoveNextAsync.
 4274                    self.completedCount = CompleteCount;
 4275                    self.completionSource.TrySetException(ex);
 4276                    return;
 4277                }
 4278
 4279                SUCCESS:
 4280                if (!self.TrySetResult())
 4281                {
 4282                    if (self.syncRunning) return;
 4283                    self.running5 = true; // as complete, no more call MoveNextAsync.
 4284                    try
 4285                    {
 4286                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 4287                    }
 4288                    catch (Exception ex)
 4289                    {
 4290                        self.completedCount = CompleteCount;
 4291                        self.completionSource.TrySetException(ex);
 4292                        return;
 4293                    }
 4294
 4295                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 4296                }
 4297                return;
 4298                COMPLETE:
 4299                self.completionSource.TrySetResult(false);
 4300                return;
 4301            }
 4302
 4303            static void Completed6(object state)
 4304            {
 4305                var self = (_CombineLatest)state;
 4306                self.running6 = false;
 4307
 4308                try
 4309                {
 4310                    if (self.awaiter6.GetResult())
 4311                    {
 4312                        self.hasCurrent6 = true;
 4313                        self.current6 = self.enumerator6.Current;
 4314                        goto SUCCESS;
 4315                    }
 4316                    else
 4317                    {
 4318                        self.running6 = true; // as complete, no more call MoveNextAsync.
 4319                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4320                        {
 4321                            goto COMPLETE;
 4322                        }
 4323                        return;
 4324                    }
 4325                }
 4326                catch (Exception ex)
 4327                {
 4328                    self.running6 = true; // as complete, no more call MoveNextAsync.
 4329                    self.completedCount = CompleteCount;
 4330                    self.completionSource.TrySetException(ex);
 4331                    return;
 4332                }
 4333
 4334                SUCCESS:
 4335                if (!self.TrySetResult())
 4336                {
 4337                    if (self.syncRunning) return;
 4338                    self.running6 = true; // as complete, no more call MoveNextAsync.
 4339                    try
 4340                    {
 4341                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 4342                    }
 4343                    catch (Exception ex)
 4344                    {
 4345                        self.completedCount = CompleteCount;
 4346                        self.completionSource.TrySetException(ex);
 4347                        return;
 4348                    }
 4349
 4350                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 4351                }
 4352                return;
 4353                COMPLETE:
 4354                self.completionSource.TrySetResult(false);
 4355                return;
 4356            }
 4357
 4358            static void Completed7(object state)
 4359            {
 4360                var self = (_CombineLatest)state;
 4361                self.running7 = false;
 4362
 4363                try
 4364                {
 4365                    if (self.awaiter7.GetResult())
 4366                    {
 4367                        self.hasCurrent7 = true;
 4368                        self.current7 = self.enumerator7.Current;
 4369                        goto SUCCESS;
 4370                    }
 4371                    else
 4372                    {
 4373                        self.running7 = true; // as complete, no more call MoveNextAsync.
 4374                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4375                        {
 4376                            goto COMPLETE;
 4377                        }
 4378                        return;
 4379                    }
 4380                }
 4381                catch (Exception ex)
 4382                {
 4383                    self.running7 = true; // as complete, no more call MoveNextAsync.
 4384                    self.completedCount = CompleteCount;
 4385                    self.completionSource.TrySetException(ex);
 4386                    return;
 4387                }
 4388
 4389                SUCCESS:
 4390                if (!self.TrySetResult())
 4391                {
 4392                    if (self.syncRunning) return;
 4393                    self.running7 = true; // as complete, no more call MoveNextAsync.
 4394                    try
 4395                    {
 4396                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 4397                    }
 4398                    catch (Exception ex)
 4399                    {
 4400                        self.completedCount = CompleteCount;
 4401                        self.completionSource.TrySetException(ex);
 4402                        return;
 4403                    }
 4404
 4405                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 4406                }
 4407                return;
 4408                COMPLETE:
 4409                self.completionSource.TrySetResult(false);
 4410                return;
 4411            }
 4412
 4413            static void Completed8(object state)
 4414            {
 4415                var self = (_CombineLatest)state;
 4416                self.running8 = false;
 4417
 4418                try
 4419                {
 4420                    if (self.awaiter8.GetResult())
 4421                    {
 4422                        self.hasCurrent8 = true;
 4423                        self.current8 = self.enumerator8.Current;
 4424                        goto SUCCESS;
 4425                    }
 4426                    else
 4427                    {
 4428                        self.running8 = true; // as complete, no more call MoveNextAsync.
 4429                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4430                        {
 4431                            goto COMPLETE;
 4432                        }
 4433                        return;
 4434                    }
 4435                }
 4436                catch (Exception ex)
 4437                {
 4438                    self.running8 = true; // as complete, no more call MoveNextAsync.
 4439                    self.completedCount = CompleteCount;
 4440                    self.completionSource.TrySetException(ex);
 4441                    return;
 4442                }
 4443
 4444                SUCCESS:
 4445                if (!self.TrySetResult())
 4446                {
 4447                    if (self.syncRunning) return;
 4448                    self.running8 = true; // as complete, no more call MoveNextAsync.
 4449                    try
 4450                    {
 4451                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 4452                    }
 4453                    catch (Exception ex)
 4454                    {
 4455                        self.completedCount = CompleteCount;
 4456                        self.completionSource.TrySetException(ex);
 4457                        return;
 4458                    }
 4459
 4460                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 4461                }
 4462                return;
 4463                COMPLETE:
 4464                self.completionSource.TrySetResult(false);
 4465                return;
 4466            }
 4467
 4468            static void Completed9(object state)
 4469            {
 4470                var self = (_CombineLatest)state;
 4471                self.running9 = false;
 4472
 4473                try
 4474                {
 4475                    if (self.awaiter9.GetResult())
 4476                    {
 4477                        self.hasCurrent9 = true;
 4478                        self.current9 = self.enumerator9.Current;
 4479                        goto SUCCESS;
 4480                    }
 4481                    else
 4482                    {
 4483                        self.running9 = true; // as complete, no more call MoveNextAsync.
 4484                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4485                        {
 4486                            goto COMPLETE;
 4487                        }
 4488                        return;
 4489                    }
 4490                }
 4491                catch (Exception ex)
 4492                {
 4493                    self.running9 = true; // as complete, no more call MoveNextAsync.
 4494                    self.completedCount = CompleteCount;
 4495                    self.completionSource.TrySetException(ex);
 4496                    return;
 4497                }
 4498
 4499                SUCCESS:
 4500                if (!self.TrySetResult())
 4501                {
 4502                    if (self.syncRunning) return;
 4503                    self.running9 = true; // as complete, no more call MoveNextAsync.
 4504                    try
 4505                    {
 4506                        self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter();
 4507                    }
 4508                    catch (Exception ex)
 4509                    {
 4510                        self.completedCount = CompleteCount;
 4511                        self.completionSource.TrySetException(ex);
 4512                        return;
 4513                    }
 4514
 4515                    self.awaiter9.SourceOnCompleted(Completed9Delegate, self);
 4516                }
 4517                return;
 4518                COMPLETE:
 4519                self.completionSource.TrySetResult(false);
 4520                return;
 4521            }
 4522
 4523            bool TrySetResult()
 4524            {
 4525                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 4526                {
 4527                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 4528                    completionSource.TrySetResult(true);
 4529                    return true;
 4530                }
 4531                else
 4532                {
 4533                    return false;
 4534                }
 4535            }
 4536
 4537            public async UniTask DisposeAsync()
 4538            {
 4539                TaskTracker.RemoveTracking(this);
 4540                if (enumerator1 != null)
 4541                {
 4542                    await enumerator1.DisposeAsync();
 4543                }
 4544                if (enumerator2 != null)
 4545                {
 4546                    await enumerator2.DisposeAsync();
 4547                }
 4548                if (enumerator3 != null)
 4549                {
 4550                    await enumerator3.DisposeAsync();
 4551                }
 4552                if (enumerator4 != null)
 4553                {
 4554                    await enumerator4.DisposeAsync();
 4555                }
 4556                if (enumerator5 != null)
 4557                {
 4558                    await enumerator5.DisposeAsync();
 4559                }
 4560                if (enumerator6 != null)
 4561                {
 4562                    await enumerator6.DisposeAsync();
 4563                }
 4564                if (enumerator7 != null)
 4565                {
 4566                    await enumerator7.DisposeAsync();
 4567                }
 4568                if (enumerator8 != null)
 4569                {
 4570                    await enumerator8.DisposeAsync();
 4571                }
 4572                if (enumerator9 != null)
 4573                {
 4574                    await enumerator9.DisposeAsync();
 4575                }
 4576            }
 4577        }
 4578    }
 4579
 4580    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> : IUniTaskAsyncEnumerable<TResult>
 4581    {
 4582        readonly IUniTaskAsyncEnumerable<T1> source1;
 4583        readonly IUniTaskAsyncEnumerable<T2> source2;
 4584        readonly IUniTaskAsyncEnumerable<T3> source3;
 4585        readonly IUniTaskAsyncEnumerable<T4> source4;
 4586        readonly IUniTaskAsyncEnumerable<T5> source5;
 4587        readonly IUniTaskAsyncEnumerable<T6> source6;
 4588        readonly IUniTaskAsyncEnumerable<T7> source7;
 4589        readonly IUniTaskAsyncEnumerable<T8> source8;
 4590        readonly IUniTaskAsyncEnumerable<T9> source9;
 4591        readonly IUniTaskAsyncEnumerable<T10> source10;
 4592
 4593        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector;
 4594
 4595        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 4596        {
 4597            this.source1 = source1;
 4598            this.source2 = source2;
 4599            this.source3 = source3;
 4600            this.source4 = source4;
 4601            this.source5 = source5;
 4602            this.source6 = source6;
 4603            this.source7 = source7;
 4604            this.source8 = source8;
 4605            this.source9 = source9;
 4606            this.source10 = source10;
 4607
 4608            this.resultSelector = resultSelector;
 4609        }
 4610
 4611        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 4612        {
 4613            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, s
 4614        }
 4615
 4616        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 4617        {
 4618            static readonly Action<object> Completed1Delegate = Completed1;
 4619            static readonly Action<object> Completed2Delegate = Completed2;
 4620            static readonly Action<object> Completed3Delegate = Completed3;
 4621            static readonly Action<object> Completed4Delegate = Completed4;
 4622            static readonly Action<object> Completed5Delegate = Completed5;
 4623            static readonly Action<object> Completed6Delegate = Completed6;
 4624            static readonly Action<object> Completed7Delegate = Completed7;
 4625            static readonly Action<object> Completed8Delegate = Completed8;
 4626            static readonly Action<object> Completed9Delegate = Completed9;
 4627            static readonly Action<object> Completed10Delegate = Completed10;
 4628            const int CompleteCount = 10;
 4629
 4630            readonly IUniTaskAsyncEnumerable<T1> source1;
 4631            readonly IUniTaskAsyncEnumerable<T2> source2;
 4632            readonly IUniTaskAsyncEnumerable<T3> source3;
 4633            readonly IUniTaskAsyncEnumerable<T4> source4;
 4634            readonly IUniTaskAsyncEnumerable<T5> source5;
 4635            readonly IUniTaskAsyncEnumerable<T6> source6;
 4636            readonly IUniTaskAsyncEnumerable<T7> source7;
 4637            readonly IUniTaskAsyncEnumerable<T8> source8;
 4638            readonly IUniTaskAsyncEnumerable<T9> source9;
 4639            readonly IUniTaskAsyncEnumerable<T10> source10;
 4640
 4641            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector;
 4642            CancellationToken cancellationToken;
 4643
 4644            IUniTaskAsyncEnumerator<T1> enumerator1;
 4645            UniTask<bool>.Awaiter awaiter1;
 4646            bool hasCurrent1;
 4647            bool running1;
 4648            T1 current1;
 4649
 4650            IUniTaskAsyncEnumerator<T2> enumerator2;
 4651            UniTask<bool>.Awaiter awaiter2;
 4652            bool hasCurrent2;
 4653            bool running2;
 4654            T2 current2;
 4655
 4656            IUniTaskAsyncEnumerator<T3> enumerator3;
 4657            UniTask<bool>.Awaiter awaiter3;
 4658            bool hasCurrent3;
 4659            bool running3;
 4660            T3 current3;
 4661
 4662            IUniTaskAsyncEnumerator<T4> enumerator4;
 4663            UniTask<bool>.Awaiter awaiter4;
 4664            bool hasCurrent4;
 4665            bool running4;
 4666            T4 current4;
 4667
 4668            IUniTaskAsyncEnumerator<T5> enumerator5;
 4669            UniTask<bool>.Awaiter awaiter5;
 4670            bool hasCurrent5;
 4671            bool running5;
 4672            T5 current5;
 4673
 4674            IUniTaskAsyncEnumerator<T6> enumerator6;
 4675            UniTask<bool>.Awaiter awaiter6;
 4676            bool hasCurrent6;
 4677            bool running6;
 4678            T6 current6;
 4679
 4680            IUniTaskAsyncEnumerator<T7> enumerator7;
 4681            UniTask<bool>.Awaiter awaiter7;
 4682            bool hasCurrent7;
 4683            bool running7;
 4684            T7 current7;
 4685
 4686            IUniTaskAsyncEnumerator<T8> enumerator8;
 4687            UniTask<bool>.Awaiter awaiter8;
 4688            bool hasCurrent8;
 4689            bool running8;
 4690            T8 current8;
 4691
 4692            IUniTaskAsyncEnumerator<T9> enumerator9;
 4693            UniTask<bool>.Awaiter awaiter9;
 4694            bool hasCurrent9;
 4695            bool running9;
 4696            T9 current9;
 4697
 4698            IUniTaskAsyncEnumerator<T10> enumerator10;
 4699            UniTask<bool>.Awaiter awaiter10;
 4700            bool hasCurrent10;
 4701            bool running10;
 4702            T10 current10;
 4703
 4704            int completedCount;
 4705            bool syncRunning;
 4706            TResult result;
 4707
 4708            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 4709            {
 4710                this.source1 = source1;
 4711                this.source2 = source2;
 4712                this.source3 = source3;
 4713                this.source4 = source4;
 4714                this.source5 = source5;
 4715                this.source6 = source6;
 4716                this.source7 = source7;
 4717                this.source8 = source8;
 4718                this.source9 = source9;
 4719                this.source10 = source10;
 4720
 4721                this.resultSelector = resultSelector;
 4722                this.cancellationToken = cancellationToken;
 4723                TaskTracker.TrackActiveTask(this, 3);
 4724            }
 4725
 4726            public TResult Current => result;
 4727
 4728            public UniTask<bool> MoveNextAsync()
 4729            {
 4730                cancellationToken.ThrowIfCancellationRequested();
 4731                if (completedCount == CompleteCount) return CompletedTasks.False;
 4732
 4733                if (enumerator1 == null)
 4734                {
 4735                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 4736                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 4737                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 4738                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 4739                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 4740                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 4741                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 4742                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 4743                    enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
 4744                    enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
 4745                }
 4746
 4747                completionSource.Reset();
 4748
 4749                AGAIN:
 4750                syncRunning = true;
 4751                if (!running1)
 4752                {
 4753                    running1 = true;
 4754                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 4755                    if (awaiter1.IsCompleted)
 4756                    {
 4757                        Completed1(this);
 4758                    }
 4759                    else
 4760                    {
 4761                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 4762                    }
 4763                }
 4764                if (!running2)
 4765                {
 4766                    running2 = true;
 4767                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 4768                    if (awaiter2.IsCompleted)
 4769                    {
 4770                        Completed2(this);
 4771                    }
 4772                    else
 4773                    {
 4774                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 4775                    }
 4776                }
 4777                if (!running3)
 4778                {
 4779                    running3 = true;
 4780                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 4781                    if (awaiter3.IsCompleted)
 4782                    {
 4783                        Completed3(this);
 4784                    }
 4785                    else
 4786                    {
 4787                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 4788                    }
 4789                }
 4790                if (!running4)
 4791                {
 4792                    running4 = true;
 4793                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 4794                    if (awaiter4.IsCompleted)
 4795                    {
 4796                        Completed4(this);
 4797                    }
 4798                    else
 4799                    {
 4800                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 4801                    }
 4802                }
 4803                if (!running5)
 4804                {
 4805                    running5 = true;
 4806                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 4807                    if (awaiter5.IsCompleted)
 4808                    {
 4809                        Completed5(this);
 4810                    }
 4811                    else
 4812                    {
 4813                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 4814                    }
 4815                }
 4816                if (!running6)
 4817                {
 4818                    running6 = true;
 4819                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 4820                    if (awaiter6.IsCompleted)
 4821                    {
 4822                        Completed6(this);
 4823                    }
 4824                    else
 4825                    {
 4826                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 4827                    }
 4828                }
 4829                if (!running7)
 4830                {
 4831                    running7 = true;
 4832                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 4833                    if (awaiter7.IsCompleted)
 4834                    {
 4835                        Completed7(this);
 4836                    }
 4837                    else
 4838                    {
 4839                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 4840                    }
 4841                }
 4842                if (!running8)
 4843                {
 4844                    running8 = true;
 4845                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 4846                    if (awaiter8.IsCompleted)
 4847                    {
 4848                        Completed8(this);
 4849                    }
 4850                    else
 4851                    {
 4852                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 4853                    }
 4854                }
 4855                if (!running9)
 4856                {
 4857                    running9 = true;
 4858                    awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
 4859                    if (awaiter9.IsCompleted)
 4860                    {
 4861                        Completed9(this);
 4862                    }
 4863                    else
 4864                    {
 4865                        awaiter9.SourceOnCompleted(Completed9Delegate, this);
 4866                    }
 4867                }
 4868                if (!running10)
 4869                {
 4870                    running10 = true;
 4871                    awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
 4872                    if (awaiter10.IsCompleted)
 4873                    {
 4874                        Completed10(this);
 4875                    }
 4876                    else
 4877                    {
 4878                        awaiter10.SourceOnCompleted(Completed10Delegate, this);
 4879                    }
 4880                }
 4881
 4882                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 4883                {
 4884                    goto AGAIN;
 4885                }
 4886                syncRunning = false;
 4887
 4888                return new UniTask<bool>(this, completionSource.Version);
 4889            }
 4890
 4891            static void Completed1(object state)
 4892            {
 4893                var self = (_CombineLatest)state;
 4894                self.running1 = false;
 4895
 4896                try
 4897                {
 4898                    if (self.awaiter1.GetResult())
 4899                    {
 4900                        self.hasCurrent1 = true;
 4901                        self.current1 = self.enumerator1.Current;
 4902                        goto SUCCESS;
 4903                    }
 4904                    else
 4905                    {
 4906                        self.running1 = true; // as complete, no more call MoveNextAsync.
 4907                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4908                        {
 4909                            goto COMPLETE;
 4910                        }
 4911                        return;
 4912                    }
 4913                }
 4914                catch (Exception ex)
 4915                {
 4916                    self.running1 = true; // as complete, no more call MoveNextAsync.
 4917                    self.completedCount = CompleteCount;
 4918                    self.completionSource.TrySetException(ex);
 4919                    return;
 4920                }
 4921
 4922                SUCCESS:
 4923                if (!self.TrySetResult())
 4924                {
 4925                    if (self.syncRunning) return;
 4926                    self.running1 = true; // as complete, no more call MoveNextAsync.
 4927                    try
 4928                    {
 4929                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 4930                    }
 4931                    catch (Exception ex)
 4932                    {
 4933                        self.completedCount = CompleteCount;
 4934                        self.completionSource.TrySetException(ex);
 4935                        return;
 4936                    }
 4937
 4938                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 4939                }
 4940                return;
 4941                COMPLETE:
 4942                self.completionSource.TrySetResult(false);
 4943                return;
 4944            }
 4945
 4946            static void Completed2(object state)
 4947            {
 4948                var self = (_CombineLatest)state;
 4949                self.running2 = false;
 4950
 4951                try
 4952                {
 4953                    if (self.awaiter2.GetResult())
 4954                    {
 4955                        self.hasCurrent2 = true;
 4956                        self.current2 = self.enumerator2.Current;
 4957                        goto SUCCESS;
 4958                    }
 4959                    else
 4960                    {
 4961                        self.running2 = true; // as complete, no more call MoveNextAsync.
 4962                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 4963                        {
 4964                            goto COMPLETE;
 4965                        }
 4966                        return;
 4967                    }
 4968                }
 4969                catch (Exception ex)
 4970                {
 4971                    self.running2 = true; // as complete, no more call MoveNextAsync.
 4972                    self.completedCount = CompleteCount;
 4973                    self.completionSource.TrySetException(ex);
 4974                    return;
 4975                }
 4976
 4977                SUCCESS:
 4978                if (!self.TrySetResult())
 4979                {
 4980                    if (self.syncRunning) return;
 4981                    self.running2 = true; // as complete, no more call MoveNextAsync.
 4982                    try
 4983                    {
 4984                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 4985                    }
 4986                    catch (Exception ex)
 4987                    {
 4988                        self.completedCount = CompleteCount;
 4989                        self.completionSource.TrySetException(ex);
 4990                        return;
 4991                    }
 4992
 4993                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 4994                }
 4995                return;
 4996                COMPLETE:
 4997                self.completionSource.TrySetResult(false);
 4998                return;
 4999            }
 5000
 5001            static void Completed3(object state)
 5002            {
 5003                var self = (_CombineLatest)state;
 5004                self.running3 = false;
 5005
 5006                try
 5007                {
 5008                    if (self.awaiter3.GetResult())
 5009                    {
 5010                        self.hasCurrent3 = true;
 5011                        self.current3 = self.enumerator3.Current;
 5012                        goto SUCCESS;
 5013                    }
 5014                    else
 5015                    {
 5016                        self.running3 = true; // as complete, no more call MoveNextAsync.
 5017                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5018                        {
 5019                            goto COMPLETE;
 5020                        }
 5021                        return;
 5022                    }
 5023                }
 5024                catch (Exception ex)
 5025                {
 5026                    self.running3 = true; // as complete, no more call MoveNextAsync.
 5027                    self.completedCount = CompleteCount;
 5028                    self.completionSource.TrySetException(ex);
 5029                    return;
 5030                }
 5031
 5032                SUCCESS:
 5033                if (!self.TrySetResult())
 5034                {
 5035                    if (self.syncRunning) return;
 5036                    self.running3 = true; // as complete, no more call MoveNextAsync.
 5037                    try
 5038                    {
 5039                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 5040                    }
 5041                    catch (Exception ex)
 5042                    {
 5043                        self.completedCount = CompleteCount;
 5044                        self.completionSource.TrySetException(ex);
 5045                        return;
 5046                    }
 5047
 5048                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 5049                }
 5050                return;
 5051                COMPLETE:
 5052                self.completionSource.TrySetResult(false);
 5053                return;
 5054            }
 5055
 5056            static void Completed4(object state)
 5057            {
 5058                var self = (_CombineLatest)state;
 5059                self.running4 = false;
 5060
 5061                try
 5062                {
 5063                    if (self.awaiter4.GetResult())
 5064                    {
 5065                        self.hasCurrent4 = true;
 5066                        self.current4 = self.enumerator4.Current;
 5067                        goto SUCCESS;
 5068                    }
 5069                    else
 5070                    {
 5071                        self.running4 = true; // as complete, no more call MoveNextAsync.
 5072                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5073                        {
 5074                            goto COMPLETE;
 5075                        }
 5076                        return;
 5077                    }
 5078                }
 5079                catch (Exception ex)
 5080                {
 5081                    self.running4 = true; // as complete, no more call MoveNextAsync.
 5082                    self.completedCount = CompleteCount;
 5083                    self.completionSource.TrySetException(ex);
 5084                    return;
 5085                }
 5086
 5087                SUCCESS:
 5088                if (!self.TrySetResult())
 5089                {
 5090                    if (self.syncRunning) return;
 5091                    self.running4 = true; // as complete, no more call MoveNextAsync.
 5092                    try
 5093                    {
 5094                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 5095                    }
 5096                    catch (Exception ex)
 5097                    {
 5098                        self.completedCount = CompleteCount;
 5099                        self.completionSource.TrySetException(ex);
 5100                        return;
 5101                    }
 5102
 5103                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 5104                }
 5105                return;
 5106                COMPLETE:
 5107                self.completionSource.TrySetResult(false);
 5108                return;
 5109            }
 5110
 5111            static void Completed5(object state)
 5112            {
 5113                var self = (_CombineLatest)state;
 5114                self.running5 = false;
 5115
 5116                try
 5117                {
 5118                    if (self.awaiter5.GetResult())
 5119                    {
 5120                        self.hasCurrent5 = true;
 5121                        self.current5 = self.enumerator5.Current;
 5122                        goto SUCCESS;
 5123                    }
 5124                    else
 5125                    {
 5126                        self.running5 = true; // as complete, no more call MoveNextAsync.
 5127                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5128                        {
 5129                            goto COMPLETE;
 5130                        }
 5131                        return;
 5132                    }
 5133                }
 5134                catch (Exception ex)
 5135                {
 5136                    self.running5 = true; // as complete, no more call MoveNextAsync.
 5137                    self.completedCount = CompleteCount;
 5138                    self.completionSource.TrySetException(ex);
 5139                    return;
 5140                }
 5141
 5142                SUCCESS:
 5143                if (!self.TrySetResult())
 5144                {
 5145                    if (self.syncRunning) return;
 5146                    self.running5 = true; // as complete, no more call MoveNextAsync.
 5147                    try
 5148                    {
 5149                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 5150                    }
 5151                    catch (Exception ex)
 5152                    {
 5153                        self.completedCount = CompleteCount;
 5154                        self.completionSource.TrySetException(ex);
 5155                        return;
 5156                    }
 5157
 5158                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 5159                }
 5160                return;
 5161                COMPLETE:
 5162                self.completionSource.TrySetResult(false);
 5163                return;
 5164            }
 5165
 5166            static void Completed6(object state)
 5167            {
 5168                var self = (_CombineLatest)state;
 5169                self.running6 = false;
 5170
 5171                try
 5172                {
 5173                    if (self.awaiter6.GetResult())
 5174                    {
 5175                        self.hasCurrent6 = true;
 5176                        self.current6 = self.enumerator6.Current;
 5177                        goto SUCCESS;
 5178                    }
 5179                    else
 5180                    {
 5181                        self.running6 = true; // as complete, no more call MoveNextAsync.
 5182                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5183                        {
 5184                            goto COMPLETE;
 5185                        }
 5186                        return;
 5187                    }
 5188                }
 5189                catch (Exception ex)
 5190                {
 5191                    self.running6 = true; // as complete, no more call MoveNextAsync.
 5192                    self.completedCount = CompleteCount;
 5193                    self.completionSource.TrySetException(ex);
 5194                    return;
 5195                }
 5196
 5197                SUCCESS:
 5198                if (!self.TrySetResult())
 5199                {
 5200                    if (self.syncRunning) return;
 5201                    self.running6 = true; // as complete, no more call MoveNextAsync.
 5202                    try
 5203                    {
 5204                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 5205                    }
 5206                    catch (Exception ex)
 5207                    {
 5208                        self.completedCount = CompleteCount;
 5209                        self.completionSource.TrySetException(ex);
 5210                        return;
 5211                    }
 5212
 5213                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 5214                }
 5215                return;
 5216                COMPLETE:
 5217                self.completionSource.TrySetResult(false);
 5218                return;
 5219            }
 5220
 5221            static void Completed7(object state)
 5222            {
 5223                var self = (_CombineLatest)state;
 5224                self.running7 = false;
 5225
 5226                try
 5227                {
 5228                    if (self.awaiter7.GetResult())
 5229                    {
 5230                        self.hasCurrent7 = true;
 5231                        self.current7 = self.enumerator7.Current;
 5232                        goto SUCCESS;
 5233                    }
 5234                    else
 5235                    {
 5236                        self.running7 = true; // as complete, no more call MoveNextAsync.
 5237                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5238                        {
 5239                            goto COMPLETE;
 5240                        }
 5241                        return;
 5242                    }
 5243                }
 5244                catch (Exception ex)
 5245                {
 5246                    self.running7 = true; // as complete, no more call MoveNextAsync.
 5247                    self.completedCount = CompleteCount;
 5248                    self.completionSource.TrySetException(ex);
 5249                    return;
 5250                }
 5251
 5252                SUCCESS:
 5253                if (!self.TrySetResult())
 5254                {
 5255                    if (self.syncRunning) return;
 5256                    self.running7 = true; // as complete, no more call MoveNextAsync.
 5257                    try
 5258                    {
 5259                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 5260                    }
 5261                    catch (Exception ex)
 5262                    {
 5263                        self.completedCount = CompleteCount;
 5264                        self.completionSource.TrySetException(ex);
 5265                        return;
 5266                    }
 5267
 5268                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 5269                }
 5270                return;
 5271                COMPLETE:
 5272                self.completionSource.TrySetResult(false);
 5273                return;
 5274            }
 5275
 5276            static void Completed8(object state)
 5277            {
 5278                var self = (_CombineLatest)state;
 5279                self.running8 = false;
 5280
 5281                try
 5282                {
 5283                    if (self.awaiter8.GetResult())
 5284                    {
 5285                        self.hasCurrent8 = true;
 5286                        self.current8 = self.enumerator8.Current;
 5287                        goto SUCCESS;
 5288                    }
 5289                    else
 5290                    {
 5291                        self.running8 = true; // as complete, no more call MoveNextAsync.
 5292                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5293                        {
 5294                            goto COMPLETE;
 5295                        }
 5296                        return;
 5297                    }
 5298                }
 5299                catch (Exception ex)
 5300                {
 5301                    self.running8 = true; // as complete, no more call MoveNextAsync.
 5302                    self.completedCount = CompleteCount;
 5303                    self.completionSource.TrySetException(ex);
 5304                    return;
 5305                }
 5306
 5307                SUCCESS:
 5308                if (!self.TrySetResult())
 5309                {
 5310                    if (self.syncRunning) return;
 5311                    self.running8 = true; // as complete, no more call MoveNextAsync.
 5312                    try
 5313                    {
 5314                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 5315                    }
 5316                    catch (Exception ex)
 5317                    {
 5318                        self.completedCount = CompleteCount;
 5319                        self.completionSource.TrySetException(ex);
 5320                        return;
 5321                    }
 5322
 5323                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 5324                }
 5325                return;
 5326                COMPLETE:
 5327                self.completionSource.TrySetResult(false);
 5328                return;
 5329            }
 5330
 5331            static void Completed9(object state)
 5332            {
 5333                var self = (_CombineLatest)state;
 5334                self.running9 = false;
 5335
 5336                try
 5337                {
 5338                    if (self.awaiter9.GetResult())
 5339                    {
 5340                        self.hasCurrent9 = true;
 5341                        self.current9 = self.enumerator9.Current;
 5342                        goto SUCCESS;
 5343                    }
 5344                    else
 5345                    {
 5346                        self.running9 = true; // as complete, no more call MoveNextAsync.
 5347                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5348                        {
 5349                            goto COMPLETE;
 5350                        }
 5351                        return;
 5352                    }
 5353                }
 5354                catch (Exception ex)
 5355                {
 5356                    self.running9 = true; // as complete, no more call MoveNextAsync.
 5357                    self.completedCount = CompleteCount;
 5358                    self.completionSource.TrySetException(ex);
 5359                    return;
 5360                }
 5361
 5362                SUCCESS:
 5363                if (!self.TrySetResult())
 5364                {
 5365                    if (self.syncRunning) return;
 5366                    self.running9 = true; // as complete, no more call MoveNextAsync.
 5367                    try
 5368                    {
 5369                        self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter();
 5370                    }
 5371                    catch (Exception ex)
 5372                    {
 5373                        self.completedCount = CompleteCount;
 5374                        self.completionSource.TrySetException(ex);
 5375                        return;
 5376                    }
 5377
 5378                    self.awaiter9.SourceOnCompleted(Completed9Delegate, self);
 5379                }
 5380                return;
 5381                COMPLETE:
 5382                self.completionSource.TrySetResult(false);
 5383                return;
 5384            }
 5385
 5386            static void Completed10(object state)
 5387            {
 5388                var self = (_CombineLatest)state;
 5389                self.running10 = false;
 5390
 5391                try
 5392                {
 5393                    if (self.awaiter10.GetResult())
 5394                    {
 5395                        self.hasCurrent10 = true;
 5396                        self.current10 = self.enumerator10.Current;
 5397                        goto SUCCESS;
 5398                    }
 5399                    else
 5400                    {
 5401                        self.running10 = true; // as complete, no more call MoveNextAsync.
 5402                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5403                        {
 5404                            goto COMPLETE;
 5405                        }
 5406                        return;
 5407                    }
 5408                }
 5409                catch (Exception ex)
 5410                {
 5411                    self.running10 = true; // as complete, no more call MoveNextAsync.
 5412                    self.completedCount = CompleteCount;
 5413                    self.completionSource.TrySetException(ex);
 5414                    return;
 5415                }
 5416
 5417                SUCCESS:
 5418                if (!self.TrySetResult())
 5419                {
 5420                    if (self.syncRunning) return;
 5421                    self.running10 = true; // as complete, no more call MoveNextAsync.
 5422                    try
 5423                    {
 5424                        self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter();
 5425                    }
 5426                    catch (Exception ex)
 5427                    {
 5428                        self.completedCount = CompleteCount;
 5429                        self.completionSource.TrySetException(ex);
 5430                        return;
 5431                    }
 5432
 5433                    self.awaiter10.SourceOnCompleted(Completed10Delegate, self);
 5434                }
 5435                return;
 5436                COMPLETE:
 5437                self.completionSource.TrySetResult(false);
 5438                return;
 5439            }
 5440
 5441            bool TrySetResult()
 5442            {
 5443                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 5444                {
 5445                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 5446                    completionSource.TrySetResult(true);
 5447                    return true;
 5448                }
 5449                else
 5450                {
 5451                    return false;
 5452                }
 5453            }
 5454
 5455            public async UniTask DisposeAsync()
 5456            {
 5457                TaskTracker.RemoveTracking(this);
 5458                if (enumerator1 != null)
 5459                {
 5460                    await enumerator1.DisposeAsync();
 5461                }
 5462                if (enumerator2 != null)
 5463                {
 5464                    await enumerator2.DisposeAsync();
 5465                }
 5466                if (enumerator3 != null)
 5467                {
 5468                    await enumerator3.DisposeAsync();
 5469                }
 5470                if (enumerator4 != null)
 5471                {
 5472                    await enumerator4.DisposeAsync();
 5473                }
 5474                if (enumerator5 != null)
 5475                {
 5476                    await enumerator5.DisposeAsync();
 5477                }
 5478                if (enumerator6 != null)
 5479                {
 5480                    await enumerator6.DisposeAsync();
 5481                }
 5482                if (enumerator7 != null)
 5483                {
 5484                    await enumerator7.DisposeAsync();
 5485                }
 5486                if (enumerator8 != null)
 5487                {
 5488                    await enumerator8.DisposeAsync();
 5489                }
 5490                if (enumerator9 != null)
 5491                {
 5492                    await enumerator9.DisposeAsync();
 5493                }
 5494                if (enumerator10 != null)
 5495                {
 5496                    await enumerator10.DisposeAsync();
 5497                }
 5498            }
 5499        }
 5500    }
 5501
 5502    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> : IUniTaskAsyncEnumerable<TResul
 5503    {
 5504        readonly IUniTaskAsyncEnumerable<T1> source1;
 5505        readonly IUniTaskAsyncEnumerable<T2> source2;
 5506        readonly IUniTaskAsyncEnumerable<T3> source3;
 5507        readonly IUniTaskAsyncEnumerable<T4> source4;
 5508        readonly IUniTaskAsyncEnumerable<T5> source5;
 5509        readonly IUniTaskAsyncEnumerable<T6> source6;
 5510        readonly IUniTaskAsyncEnumerable<T7> source7;
 5511        readonly IUniTaskAsyncEnumerable<T8> source8;
 5512        readonly IUniTaskAsyncEnumerable<T9> source9;
 5513        readonly IUniTaskAsyncEnumerable<T10> source10;
 5514        readonly IUniTaskAsyncEnumerable<T11> source11;
 5515
 5516        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector;
 5517
 5518        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 5519        {
 5520            this.source1 = source1;
 5521            this.source2 = source2;
 5522            this.source3 = source3;
 5523            this.source4 = source4;
 5524            this.source5 = source5;
 5525            this.source6 = source6;
 5526            this.source7 = source7;
 5527            this.source8 = source8;
 5528            this.source9 = source9;
 5529            this.source10 = source10;
 5530            this.source11 = source11;
 5531
 5532            this.resultSelector = resultSelector;
 5533        }
 5534
 5535        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 5536        {
 5537            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, s
 5538        }
 5539
 5540        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 5541        {
 5542            static readonly Action<object> Completed1Delegate = Completed1;
 5543            static readonly Action<object> Completed2Delegate = Completed2;
 5544            static readonly Action<object> Completed3Delegate = Completed3;
 5545            static readonly Action<object> Completed4Delegate = Completed4;
 5546            static readonly Action<object> Completed5Delegate = Completed5;
 5547            static readonly Action<object> Completed6Delegate = Completed6;
 5548            static readonly Action<object> Completed7Delegate = Completed7;
 5549            static readonly Action<object> Completed8Delegate = Completed8;
 5550            static readonly Action<object> Completed9Delegate = Completed9;
 5551            static readonly Action<object> Completed10Delegate = Completed10;
 5552            static readonly Action<object> Completed11Delegate = Completed11;
 5553            const int CompleteCount = 11;
 5554
 5555            readonly IUniTaskAsyncEnumerable<T1> source1;
 5556            readonly IUniTaskAsyncEnumerable<T2> source2;
 5557            readonly IUniTaskAsyncEnumerable<T3> source3;
 5558            readonly IUniTaskAsyncEnumerable<T4> source4;
 5559            readonly IUniTaskAsyncEnumerable<T5> source5;
 5560            readonly IUniTaskAsyncEnumerable<T6> source6;
 5561            readonly IUniTaskAsyncEnumerable<T7> source7;
 5562            readonly IUniTaskAsyncEnumerable<T8> source8;
 5563            readonly IUniTaskAsyncEnumerable<T9> source9;
 5564            readonly IUniTaskAsyncEnumerable<T10> source10;
 5565            readonly IUniTaskAsyncEnumerable<T11> source11;
 5566
 5567            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector;
 5568            CancellationToken cancellationToken;
 5569
 5570            IUniTaskAsyncEnumerator<T1> enumerator1;
 5571            UniTask<bool>.Awaiter awaiter1;
 5572            bool hasCurrent1;
 5573            bool running1;
 5574            T1 current1;
 5575
 5576            IUniTaskAsyncEnumerator<T2> enumerator2;
 5577            UniTask<bool>.Awaiter awaiter2;
 5578            bool hasCurrent2;
 5579            bool running2;
 5580            T2 current2;
 5581
 5582            IUniTaskAsyncEnumerator<T3> enumerator3;
 5583            UniTask<bool>.Awaiter awaiter3;
 5584            bool hasCurrent3;
 5585            bool running3;
 5586            T3 current3;
 5587
 5588            IUniTaskAsyncEnumerator<T4> enumerator4;
 5589            UniTask<bool>.Awaiter awaiter4;
 5590            bool hasCurrent4;
 5591            bool running4;
 5592            T4 current4;
 5593
 5594            IUniTaskAsyncEnumerator<T5> enumerator5;
 5595            UniTask<bool>.Awaiter awaiter5;
 5596            bool hasCurrent5;
 5597            bool running5;
 5598            T5 current5;
 5599
 5600            IUniTaskAsyncEnumerator<T6> enumerator6;
 5601            UniTask<bool>.Awaiter awaiter6;
 5602            bool hasCurrent6;
 5603            bool running6;
 5604            T6 current6;
 5605
 5606            IUniTaskAsyncEnumerator<T7> enumerator7;
 5607            UniTask<bool>.Awaiter awaiter7;
 5608            bool hasCurrent7;
 5609            bool running7;
 5610            T7 current7;
 5611
 5612            IUniTaskAsyncEnumerator<T8> enumerator8;
 5613            UniTask<bool>.Awaiter awaiter8;
 5614            bool hasCurrent8;
 5615            bool running8;
 5616            T8 current8;
 5617
 5618            IUniTaskAsyncEnumerator<T9> enumerator9;
 5619            UniTask<bool>.Awaiter awaiter9;
 5620            bool hasCurrent9;
 5621            bool running9;
 5622            T9 current9;
 5623
 5624            IUniTaskAsyncEnumerator<T10> enumerator10;
 5625            UniTask<bool>.Awaiter awaiter10;
 5626            bool hasCurrent10;
 5627            bool running10;
 5628            T10 current10;
 5629
 5630            IUniTaskAsyncEnumerator<T11> enumerator11;
 5631            UniTask<bool>.Awaiter awaiter11;
 5632            bool hasCurrent11;
 5633            bool running11;
 5634            T11 current11;
 5635
 5636            int completedCount;
 5637            bool syncRunning;
 5638            TResult result;
 5639
 5640            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 5641            {
 5642                this.source1 = source1;
 5643                this.source2 = source2;
 5644                this.source3 = source3;
 5645                this.source4 = source4;
 5646                this.source5 = source5;
 5647                this.source6 = source6;
 5648                this.source7 = source7;
 5649                this.source8 = source8;
 5650                this.source9 = source9;
 5651                this.source10 = source10;
 5652                this.source11 = source11;
 5653
 5654                this.resultSelector = resultSelector;
 5655                this.cancellationToken = cancellationToken;
 5656                TaskTracker.TrackActiveTask(this, 3);
 5657            }
 5658
 5659            public TResult Current => result;
 5660
 5661            public UniTask<bool> MoveNextAsync()
 5662            {
 5663                cancellationToken.ThrowIfCancellationRequested();
 5664                if (completedCount == CompleteCount) return CompletedTasks.False;
 5665
 5666                if (enumerator1 == null)
 5667                {
 5668                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 5669                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 5670                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 5671                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 5672                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 5673                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 5674                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 5675                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 5676                    enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
 5677                    enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
 5678                    enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
 5679                }
 5680
 5681                completionSource.Reset();
 5682
 5683                AGAIN:
 5684                syncRunning = true;
 5685                if (!running1)
 5686                {
 5687                    running1 = true;
 5688                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 5689                    if (awaiter1.IsCompleted)
 5690                    {
 5691                        Completed1(this);
 5692                    }
 5693                    else
 5694                    {
 5695                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 5696                    }
 5697                }
 5698                if (!running2)
 5699                {
 5700                    running2 = true;
 5701                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 5702                    if (awaiter2.IsCompleted)
 5703                    {
 5704                        Completed2(this);
 5705                    }
 5706                    else
 5707                    {
 5708                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 5709                    }
 5710                }
 5711                if (!running3)
 5712                {
 5713                    running3 = true;
 5714                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 5715                    if (awaiter3.IsCompleted)
 5716                    {
 5717                        Completed3(this);
 5718                    }
 5719                    else
 5720                    {
 5721                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 5722                    }
 5723                }
 5724                if (!running4)
 5725                {
 5726                    running4 = true;
 5727                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 5728                    if (awaiter4.IsCompleted)
 5729                    {
 5730                        Completed4(this);
 5731                    }
 5732                    else
 5733                    {
 5734                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 5735                    }
 5736                }
 5737                if (!running5)
 5738                {
 5739                    running5 = true;
 5740                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 5741                    if (awaiter5.IsCompleted)
 5742                    {
 5743                        Completed5(this);
 5744                    }
 5745                    else
 5746                    {
 5747                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 5748                    }
 5749                }
 5750                if (!running6)
 5751                {
 5752                    running6 = true;
 5753                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 5754                    if (awaiter6.IsCompleted)
 5755                    {
 5756                        Completed6(this);
 5757                    }
 5758                    else
 5759                    {
 5760                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 5761                    }
 5762                }
 5763                if (!running7)
 5764                {
 5765                    running7 = true;
 5766                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 5767                    if (awaiter7.IsCompleted)
 5768                    {
 5769                        Completed7(this);
 5770                    }
 5771                    else
 5772                    {
 5773                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 5774                    }
 5775                }
 5776                if (!running8)
 5777                {
 5778                    running8 = true;
 5779                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 5780                    if (awaiter8.IsCompleted)
 5781                    {
 5782                        Completed8(this);
 5783                    }
 5784                    else
 5785                    {
 5786                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 5787                    }
 5788                }
 5789                if (!running9)
 5790                {
 5791                    running9 = true;
 5792                    awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
 5793                    if (awaiter9.IsCompleted)
 5794                    {
 5795                        Completed9(this);
 5796                    }
 5797                    else
 5798                    {
 5799                        awaiter9.SourceOnCompleted(Completed9Delegate, this);
 5800                    }
 5801                }
 5802                if (!running10)
 5803                {
 5804                    running10 = true;
 5805                    awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
 5806                    if (awaiter10.IsCompleted)
 5807                    {
 5808                        Completed10(this);
 5809                    }
 5810                    else
 5811                    {
 5812                        awaiter10.SourceOnCompleted(Completed10Delegate, this);
 5813                    }
 5814                }
 5815                if (!running11)
 5816                {
 5817                    running11 = true;
 5818                    awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
 5819                    if (awaiter11.IsCompleted)
 5820                    {
 5821                        Completed11(this);
 5822                    }
 5823                    else
 5824                    {
 5825                        awaiter11.SourceOnCompleted(Completed11Delegate, this);
 5826                    }
 5827                }
 5828
 5829                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 5830                {
 5831                    goto AGAIN;
 5832                }
 5833                syncRunning = false;
 5834
 5835                return new UniTask<bool>(this, completionSource.Version);
 5836            }
 5837
 5838            static void Completed1(object state)
 5839            {
 5840                var self = (_CombineLatest)state;
 5841                self.running1 = false;
 5842
 5843                try
 5844                {
 5845                    if (self.awaiter1.GetResult())
 5846                    {
 5847                        self.hasCurrent1 = true;
 5848                        self.current1 = self.enumerator1.Current;
 5849                        goto SUCCESS;
 5850                    }
 5851                    else
 5852                    {
 5853                        self.running1 = true; // as complete, no more call MoveNextAsync.
 5854                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5855                        {
 5856                            goto COMPLETE;
 5857                        }
 5858                        return;
 5859                    }
 5860                }
 5861                catch (Exception ex)
 5862                {
 5863                    self.running1 = true; // as complete, no more call MoveNextAsync.
 5864                    self.completedCount = CompleteCount;
 5865                    self.completionSource.TrySetException(ex);
 5866                    return;
 5867                }
 5868
 5869                SUCCESS:
 5870                if (!self.TrySetResult())
 5871                {
 5872                    if (self.syncRunning) return;
 5873                    self.running1 = true; // as complete, no more call MoveNextAsync.
 5874                    try
 5875                    {
 5876                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 5877                    }
 5878                    catch (Exception ex)
 5879                    {
 5880                        self.completedCount = CompleteCount;
 5881                        self.completionSource.TrySetException(ex);
 5882                        return;
 5883                    }
 5884
 5885                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 5886                }
 5887                return;
 5888                COMPLETE:
 5889                self.completionSource.TrySetResult(false);
 5890                return;
 5891            }
 5892
 5893            static void Completed2(object state)
 5894            {
 5895                var self = (_CombineLatest)state;
 5896                self.running2 = false;
 5897
 5898                try
 5899                {
 5900                    if (self.awaiter2.GetResult())
 5901                    {
 5902                        self.hasCurrent2 = true;
 5903                        self.current2 = self.enumerator2.Current;
 5904                        goto SUCCESS;
 5905                    }
 5906                    else
 5907                    {
 5908                        self.running2 = true; // as complete, no more call MoveNextAsync.
 5909                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5910                        {
 5911                            goto COMPLETE;
 5912                        }
 5913                        return;
 5914                    }
 5915                }
 5916                catch (Exception ex)
 5917                {
 5918                    self.running2 = true; // as complete, no more call MoveNextAsync.
 5919                    self.completedCount = CompleteCount;
 5920                    self.completionSource.TrySetException(ex);
 5921                    return;
 5922                }
 5923
 5924                SUCCESS:
 5925                if (!self.TrySetResult())
 5926                {
 5927                    if (self.syncRunning) return;
 5928                    self.running2 = true; // as complete, no more call MoveNextAsync.
 5929                    try
 5930                    {
 5931                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 5932                    }
 5933                    catch (Exception ex)
 5934                    {
 5935                        self.completedCount = CompleteCount;
 5936                        self.completionSource.TrySetException(ex);
 5937                        return;
 5938                    }
 5939
 5940                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 5941                }
 5942                return;
 5943                COMPLETE:
 5944                self.completionSource.TrySetResult(false);
 5945                return;
 5946            }
 5947
 5948            static void Completed3(object state)
 5949            {
 5950                var self = (_CombineLatest)state;
 5951                self.running3 = false;
 5952
 5953                try
 5954                {
 5955                    if (self.awaiter3.GetResult())
 5956                    {
 5957                        self.hasCurrent3 = true;
 5958                        self.current3 = self.enumerator3.Current;
 5959                        goto SUCCESS;
 5960                    }
 5961                    else
 5962                    {
 5963                        self.running3 = true; // as complete, no more call MoveNextAsync.
 5964                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 5965                        {
 5966                            goto COMPLETE;
 5967                        }
 5968                        return;
 5969                    }
 5970                }
 5971                catch (Exception ex)
 5972                {
 5973                    self.running3 = true; // as complete, no more call MoveNextAsync.
 5974                    self.completedCount = CompleteCount;
 5975                    self.completionSource.TrySetException(ex);
 5976                    return;
 5977                }
 5978
 5979                SUCCESS:
 5980                if (!self.TrySetResult())
 5981                {
 5982                    if (self.syncRunning) return;
 5983                    self.running3 = true; // as complete, no more call MoveNextAsync.
 5984                    try
 5985                    {
 5986                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 5987                    }
 5988                    catch (Exception ex)
 5989                    {
 5990                        self.completedCount = CompleteCount;
 5991                        self.completionSource.TrySetException(ex);
 5992                        return;
 5993                    }
 5994
 5995                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 5996                }
 5997                return;
 5998                COMPLETE:
 5999                self.completionSource.TrySetResult(false);
 6000                return;
 6001            }
 6002
 6003            static void Completed4(object state)
 6004            {
 6005                var self = (_CombineLatest)state;
 6006                self.running4 = false;
 6007
 6008                try
 6009                {
 6010                    if (self.awaiter4.GetResult())
 6011                    {
 6012                        self.hasCurrent4 = true;
 6013                        self.current4 = self.enumerator4.Current;
 6014                        goto SUCCESS;
 6015                    }
 6016                    else
 6017                    {
 6018                        self.running4 = true; // as complete, no more call MoveNextAsync.
 6019                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6020                        {
 6021                            goto COMPLETE;
 6022                        }
 6023                        return;
 6024                    }
 6025                }
 6026                catch (Exception ex)
 6027                {
 6028                    self.running4 = true; // as complete, no more call MoveNextAsync.
 6029                    self.completedCount = CompleteCount;
 6030                    self.completionSource.TrySetException(ex);
 6031                    return;
 6032                }
 6033
 6034                SUCCESS:
 6035                if (!self.TrySetResult())
 6036                {
 6037                    if (self.syncRunning) return;
 6038                    self.running4 = true; // as complete, no more call MoveNextAsync.
 6039                    try
 6040                    {
 6041                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 6042                    }
 6043                    catch (Exception ex)
 6044                    {
 6045                        self.completedCount = CompleteCount;
 6046                        self.completionSource.TrySetException(ex);
 6047                        return;
 6048                    }
 6049
 6050                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 6051                }
 6052                return;
 6053                COMPLETE:
 6054                self.completionSource.TrySetResult(false);
 6055                return;
 6056            }
 6057
 6058            static void Completed5(object state)
 6059            {
 6060                var self = (_CombineLatest)state;
 6061                self.running5 = false;
 6062
 6063                try
 6064                {
 6065                    if (self.awaiter5.GetResult())
 6066                    {
 6067                        self.hasCurrent5 = true;
 6068                        self.current5 = self.enumerator5.Current;
 6069                        goto SUCCESS;
 6070                    }
 6071                    else
 6072                    {
 6073                        self.running5 = true; // as complete, no more call MoveNextAsync.
 6074                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6075                        {
 6076                            goto COMPLETE;
 6077                        }
 6078                        return;
 6079                    }
 6080                }
 6081                catch (Exception ex)
 6082                {
 6083                    self.running5 = true; // as complete, no more call MoveNextAsync.
 6084                    self.completedCount = CompleteCount;
 6085                    self.completionSource.TrySetException(ex);
 6086                    return;
 6087                }
 6088
 6089                SUCCESS:
 6090                if (!self.TrySetResult())
 6091                {
 6092                    if (self.syncRunning) return;
 6093                    self.running5 = true; // as complete, no more call MoveNextAsync.
 6094                    try
 6095                    {
 6096                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 6097                    }
 6098                    catch (Exception ex)
 6099                    {
 6100                        self.completedCount = CompleteCount;
 6101                        self.completionSource.TrySetException(ex);
 6102                        return;
 6103                    }
 6104
 6105                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 6106                }
 6107                return;
 6108                COMPLETE:
 6109                self.completionSource.TrySetResult(false);
 6110                return;
 6111            }
 6112
 6113            static void Completed6(object state)
 6114            {
 6115                var self = (_CombineLatest)state;
 6116                self.running6 = false;
 6117
 6118                try
 6119                {
 6120                    if (self.awaiter6.GetResult())
 6121                    {
 6122                        self.hasCurrent6 = true;
 6123                        self.current6 = self.enumerator6.Current;
 6124                        goto SUCCESS;
 6125                    }
 6126                    else
 6127                    {
 6128                        self.running6 = true; // as complete, no more call MoveNextAsync.
 6129                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6130                        {
 6131                            goto COMPLETE;
 6132                        }
 6133                        return;
 6134                    }
 6135                }
 6136                catch (Exception ex)
 6137                {
 6138                    self.running6 = true; // as complete, no more call MoveNextAsync.
 6139                    self.completedCount = CompleteCount;
 6140                    self.completionSource.TrySetException(ex);
 6141                    return;
 6142                }
 6143
 6144                SUCCESS:
 6145                if (!self.TrySetResult())
 6146                {
 6147                    if (self.syncRunning) return;
 6148                    self.running6 = true; // as complete, no more call MoveNextAsync.
 6149                    try
 6150                    {
 6151                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 6152                    }
 6153                    catch (Exception ex)
 6154                    {
 6155                        self.completedCount = CompleteCount;
 6156                        self.completionSource.TrySetException(ex);
 6157                        return;
 6158                    }
 6159
 6160                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 6161                }
 6162                return;
 6163                COMPLETE:
 6164                self.completionSource.TrySetResult(false);
 6165                return;
 6166            }
 6167
 6168            static void Completed7(object state)
 6169            {
 6170                var self = (_CombineLatest)state;
 6171                self.running7 = false;
 6172
 6173                try
 6174                {
 6175                    if (self.awaiter7.GetResult())
 6176                    {
 6177                        self.hasCurrent7 = true;
 6178                        self.current7 = self.enumerator7.Current;
 6179                        goto SUCCESS;
 6180                    }
 6181                    else
 6182                    {
 6183                        self.running7 = true; // as complete, no more call MoveNextAsync.
 6184                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6185                        {
 6186                            goto COMPLETE;
 6187                        }
 6188                        return;
 6189                    }
 6190                }
 6191                catch (Exception ex)
 6192                {
 6193                    self.running7 = true; // as complete, no more call MoveNextAsync.
 6194                    self.completedCount = CompleteCount;
 6195                    self.completionSource.TrySetException(ex);
 6196                    return;
 6197                }
 6198
 6199                SUCCESS:
 6200                if (!self.TrySetResult())
 6201                {
 6202                    if (self.syncRunning) return;
 6203                    self.running7 = true; // as complete, no more call MoveNextAsync.
 6204                    try
 6205                    {
 6206                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 6207                    }
 6208                    catch (Exception ex)
 6209                    {
 6210                        self.completedCount = CompleteCount;
 6211                        self.completionSource.TrySetException(ex);
 6212                        return;
 6213                    }
 6214
 6215                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 6216                }
 6217                return;
 6218                COMPLETE:
 6219                self.completionSource.TrySetResult(false);
 6220                return;
 6221            }
 6222
 6223            static void Completed8(object state)
 6224            {
 6225                var self = (_CombineLatest)state;
 6226                self.running8 = false;
 6227
 6228                try
 6229                {
 6230                    if (self.awaiter8.GetResult())
 6231                    {
 6232                        self.hasCurrent8 = true;
 6233                        self.current8 = self.enumerator8.Current;
 6234                        goto SUCCESS;
 6235                    }
 6236                    else
 6237                    {
 6238                        self.running8 = true; // as complete, no more call MoveNextAsync.
 6239                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6240                        {
 6241                            goto COMPLETE;
 6242                        }
 6243                        return;
 6244                    }
 6245                }
 6246                catch (Exception ex)
 6247                {
 6248                    self.running8 = true; // as complete, no more call MoveNextAsync.
 6249                    self.completedCount = CompleteCount;
 6250                    self.completionSource.TrySetException(ex);
 6251                    return;
 6252                }
 6253
 6254                SUCCESS:
 6255                if (!self.TrySetResult())
 6256                {
 6257                    if (self.syncRunning) return;
 6258                    self.running8 = true; // as complete, no more call MoveNextAsync.
 6259                    try
 6260                    {
 6261                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 6262                    }
 6263                    catch (Exception ex)
 6264                    {
 6265                        self.completedCount = CompleteCount;
 6266                        self.completionSource.TrySetException(ex);
 6267                        return;
 6268                    }
 6269
 6270                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 6271                }
 6272                return;
 6273                COMPLETE:
 6274                self.completionSource.TrySetResult(false);
 6275                return;
 6276            }
 6277
 6278            static void Completed9(object state)
 6279            {
 6280                var self = (_CombineLatest)state;
 6281                self.running9 = false;
 6282
 6283                try
 6284                {
 6285                    if (self.awaiter9.GetResult())
 6286                    {
 6287                        self.hasCurrent9 = true;
 6288                        self.current9 = self.enumerator9.Current;
 6289                        goto SUCCESS;
 6290                    }
 6291                    else
 6292                    {
 6293                        self.running9 = true; // as complete, no more call MoveNextAsync.
 6294                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6295                        {
 6296                            goto COMPLETE;
 6297                        }
 6298                        return;
 6299                    }
 6300                }
 6301                catch (Exception ex)
 6302                {
 6303                    self.running9 = true; // as complete, no more call MoveNextAsync.
 6304                    self.completedCount = CompleteCount;
 6305                    self.completionSource.TrySetException(ex);
 6306                    return;
 6307                }
 6308
 6309                SUCCESS:
 6310                if (!self.TrySetResult())
 6311                {
 6312                    if (self.syncRunning) return;
 6313                    self.running9 = true; // as complete, no more call MoveNextAsync.
 6314                    try
 6315                    {
 6316                        self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter();
 6317                    }
 6318                    catch (Exception ex)
 6319                    {
 6320                        self.completedCount = CompleteCount;
 6321                        self.completionSource.TrySetException(ex);
 6322                        return;
 6323                    }
 6324
 6325                    self.awaiter9.SourceOnCompleted(Completed9Delegate, self);
 6326                }
 6327                return;
 6328                COMPLETE:
 6329                self.completionSource.TrySetResult(false);
 6330                return;
 6331            }
 6332
 6333            static void Completed10(object state)
 6334            {
 6335                var self = (_CombineLatest)state;
 6336                self.running10 = false;
 6337
 6338                try
 6339                {
 6340                    if (self.awaiter10.GetResult())
 6341                    {
 6342                        self.hasCurrent10 = true;
 6343                        self.current10 = self.enumerator10.Current;
 6344                        goto SUCCESS;
 6345                    }
 6346                    else
 6347                    {
 6348                        self.running10 = true; // as complete, no more call MoveNextAsync.
 6349                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6350                        {
 6351                            goto COMPLETE;
 6352                        }
 6353                        return;
 6354                    }
 6355                }
 6356                catch (Exception ex)
 6357                {
 6358                    self.running10 = true; // as complete, no more call MoveNextAsync.
 6359                    self.completedCount = CompleteCount;
 6360                    self.completionSource.TrySetException(ex);
 6361                    return;
 6362                }
 6363
 6364                SUCCESS:
 6365                if (!self.TrySetResult())
 6366                {
 6367                    if (self.syncRunning) return;
 6368                    self.running10 = true; // as complete, no more call MoveNextAsync.
 6369                    try
 6370                    {
 6371                        self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter();
 6372                    }
 6373                    catch (Exception ex)
 6374                    {
 6375                        self.completedCount = CompleteCount;
 6376                        self.completionSource.TrySetException(ex);
 6377                        return;
 6378                    }
 6379
 6380                    self.awaiter10.SourceOnCompleted(Completed10Delegate, self);
 6381                }
 6382                return;
 6383                COMPLETE:
 6384                self.completionSource.TrySetResult(false);
 6385                return;
 6386            }
 6387
 6388            static void Completed11(object state)
 6389            {
 6390                var self = (_CombineLatest)state;
 6391                self.running11 = false;
 6392
 6393                try
 6394                {
 6395                    if (self.awaiter11.GetResult())
 6396                    {
 6397                        self.hasCurrent11 = true;
 6398                        self.current11 = self.enumerator11.Current;
 6399                        goto SUCCESS;
 6400                    }
 6401                    else
 6402                    {
 6403                        self.running11 = true; // as complete, no more call MoveNextAsync.
 6404                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6405                        {
 6406                            goto COMPLETE;
 6407                        }
 6408                        return;
 6409                    }
 6410                }
 6411                catch (Exception ex)
 6412                {
 6413                    self.running11 = true; // as complete, no more call MoveNextAsync.
 6414                    self.completedCount = CompleteCount;
 6415                    self.completionSource.TrySetException(ex);
 6416                    return;
 6417                }
 6418
 6419                SUCCESS:
 6420                if (!self.TrySetResult())
 6421                {
 6422                    if (self.syncRunning) return;
 6423                    self.running11 = true; // as complete, no more call MoveNextAsync.
 6424                    try
 6425                    {
 6426                        self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter();
 6427                    }
 6428                    catch (Exception ex)
 6429                    {
 6430                        self.completedCount = CompleteCount;
 6431                        self.completionSource.TrySetException(ex);
 6432                        return;
 6433                    }
 6434
 6435                    self.awaiter11.SourceOnCompleted(Completed11Delegate, self);
 6436                }
 6437                return;
 6438                COMPLETE:
 6439                self.completionSource.TrySetResult(false);
 6440                return;
 6441            }
 6442
 6443            bool TrySetResult()
 6444            {
 6445                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 6446                {
 6447                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 6448                    completionSource.TrySetResult(true);
 6449                    return true;
 6450                }
 6451                else
 6452                {
 6453                    return false;
 6454                }
 6455            }
 6456
 6457            public async UniTask DisposeAsync()
 6458            {
 6459                TaskTracker.RemoveTracking(this);
 6460                if (enumerator1 != null)
 6461                {
 6462                    await enumerator1.DisposeAsync();
 6463                }
 6464                if (enumerator2 != null)
 6465                {
 6466                    await enumerator2.DisposeAsync();
 6467                }
 6468                if (enumerator3 != null)
 6469                {
 6470                    await enumerator3.DisposeAsync();
 6471                }
 6472                if (enumerator4 != null)
 6473                {
 6474                    await enumerator4.DisposeAsync();
 6475                }
 6476                if (enumerator5 != null)
 6477                {
 6478                    await enumerator5.DisposeAsync();
 6479                }
 6480                if (enumerator6 != null)
 6481                {
 6482                    await enumerator6.DisposeAsync();
 6483                }
 6484                if (enumerator7 != null)
 6485                {
 6486                    await enumerator7.DisposeAsync();
 6487                }
 6488                if (enumerator8 != null)
 6489                {
 6490                    await enumerator8.DisposeAsync();
 6491                }
 6492                if (enumerator9 != null)
 6493                {
 6494                    await enumerator9.DisposeAsync();
 6495                }
 6496                if (enumerator10 != null)
 6497                {
 6498                    await enumerator10.DisposeAsync();
 6499                }
 6500                if (enumerator11 != null)
 6501                {
 6502                    await enumerator11.DisposeAsync();
 6503                }
 6504            }
 6505        }
 6506    }
 6507
 6508    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> : IUniTaskAsyncEnumerable<T
 6509    {
 6510        readonly IUniTaskAsyncEnumerable<T1> source1;
 6511        readonly IUniTaskAsyncEnumerable<T2> source2;
 6512        readonly IUniTaskAsyncEnumerable<T3> source3;
 6513        readonly IUniTaskAsyncEnumerable<T4> source4;
 6514        readonly IUniTaskAsyncEnumerable<T5> source5;
 6515        readonly IUniTaskAsyncEnumerable<T6> source6;
 6516        readonly IUniTaskAsyncEnumerable<T7> source7;
 6517        readonly IUniTaskAsyncEnumerable<T8> source8;
 6518        readonly IUniTaskAsyncEnumerable<T9> source9;
 6519        readonly IUniTaskAsyncEnumerable<T10> source10;
 6520        readonly IUniTaskAsyncEnumerable<T11> source11;
 6521        readonly IUniTaskAsyncEnumerable<T12> source12;
 6522
 6523        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector;
 6524
 6525        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 6526        {
 6527            this.source1 = source1;
 6528            this.source2 = source2;
 6529            this.source3 = source3;
 6530            this.source4 = source4;
 6531            this.source5 = source5;
 6532            this.source6 = source6;
 6533            this.source7 = source7;
 6534            this.source8 = source8;
 6535            this.source9 = source9;
 6536            this.source10 = source10;
 6537            this.source11 = source11;
 6538            this.source12 = source12;
 6539
 6540            this.resultSelector = resultSelector;
 6541        }
 6542
 6543        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 6544        {
 6545            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, s
 6546        }
 6547
 6548        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 6549        {
 6550            static readonly Action<object> Completed1Delegate = Completed1;
 6551            static readonly Action<object> Completed2Delegate = Completed2;
 6552            static readonly Action<object> Completed3Delegate = Completed3;
 6553            static readonly Action<object> Completed4Delegate = Completed4;
 6554            static readonly Action<object> Completed5Delegate = Completed5;
 6555            static readonly Action<object> Completed6Delegate = Completed6;
 6556            static readonly Action<object> Completed7Delegate = Completed7;
 6557            static readonly Action<object> Completed8Delegate = Completed8;
 6558            static readonly Action<object> Completed9Delegate = Completed9;
 6559            static readonly Action<object> Completed10Delegate = Completed10;
 6560            static readonly Action<object> Completed11Delegate = Completed11;
 6561            static readonly Action<object> Completed12Delegate = Completed12;
 6562            const int CompleteCount = 12;
 6563
 6564            readonly IUniTaskAsyncEnumerable<T1> source1;
 6565            readonly IUniTaskAsyncEnumerable<T2> source2;
 6566            readonly IUniTaskAsyncEnumerable<T3> source3;
 6567            readonly IUniTaskAsyncEnumerable<T4> source4;
 6568            readonly IUniTaskAsyncEnumerable<T5> source5;
 6569            readonly IUniTaskAsyncEnumerable<T6> source6;
 6570            readonly IUniTaskAsyncEnumerable<T7> source7;
 6571            readonly IUniTaskAsyncEnumerable<T8> source8;
 6572            readonly IUniTaskAsyncEnumerable<T9> source9;
 6573            readonly IUniTaskAsyncEnumerable<T10> source10;
 6574            readonly IUniTaskAsyncEnumerable<T11> source11;
 6575            readonly IUniTaskAsyncEnumerable<T12> source12;
 6576
 6577            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector;
 6578            CancellationToken cancellationToken;
 6579
 6580            IUniTaskAsyncEnumerator<T1> enumerator1;
 6581            UniTask<bool>.Awaiter awaiter1;
 6582            bool hasCurrent1;
 6583            bool running1;
 6584            T1 current1;
 6585
 6586            IUniTaskAsyncEnumerator<T2> enumerator2;
 6587            UniTask<bool>.Awaiter awaiter2;
 6588            bool hasCurrent2;
 6589            bool running2;
 6590            T2 current2;
 6591
 6592            IUniTaskAsyncEnumerator<T3> enumerator3;
 6593            UniTask<bool>.Awaiter awaiter3;
 6594            bool hasCurrent3;
 6595            bool running3;
 6596            T3 current3;
 6597
 6598            IUniTaskAsyncEnumerator<T4> enumerator4;
 6599            UniTask<bool>.Awaiter awaiter4;
 6600            bool hasCurrent4;
 6601            bool running4;
 6602            T4 current4;
 6603
 6604            IUniTaskAsyncEnumerator<T5> enumerator5;
 6605            UniTask<bool>.Awaiter awaiter5;
 6606            bool hasCurrent5;
 6607            bool running5;
 6608            T5 current5;
 6609
 6610            IUniTaskAsyncEnumerator<T6> enumerator6;
 6611            UniTask<bool>.Awaiter awaiter6;
 6612            bool hasCurrent6;
 6613            bool running6;
 6614            T6 current6;
 6615
 6616            IUniTaskAsyncEnumerator<T7> enumerator7;
 6617            UniTask<bool>.Awaiter awaiter7;
 6618            bool hasCurrent7;
 6619            bool running7;
 6620            T7 current7;
 6621
 6622            IUniTaskAsyncEnumerator<T8> enumerator8;
 6623            UniTask<bool>.Awaiter awaiter8;
 6624            bool hasCurrent8;
 6625            bool running8;
 6626            T8 current8;
 6627
 6628            IUniTaskAsyncEnumerator<T9> enumerator9;
 6629            UniTask<bool>.Awaiter awaiter9;
 6630            bool hasCurrent9;
 6631            bool running9;
 6632            T9 current9;
 6633
 6634            IUniTaskAsyncEnumerator<T10> enumerator10;
 6635            UniTask<bool>.Awaiter awaiter10;
 6636            bool hasCurrent10;
 6637            bool running10;
 6638            T10 current10;
 6639
 6640            IUniTaskAsyncEnumerator<T11> enumerator11;
 6641            UniTask<bool>.Awaiter awaiter11;
 6642            bool hasCurrent11;
 6643            bool running11;
 6644            T11 current11;
 6645
 6646            IUniTaskAsyncEnumerator<T12> enumerator12;
 6647            UniTask<bool>.Awaiter awaiter12;
 6648            bool hasCurrent12;
 6649            bool running12;
 6650            T12 current12;
 6651
 6652            int completedCount;
 6653            bool syncRunning;
 6654            TResult result;
 6655
 6656            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 6657            {
 6658                this.source1 = source1;
 6659                this.source2 = source2;
 6660                this.source3 = source3;
 6661                this.source4 = source4;
 6662                this.source5 = source5;
 6663                this.source6 = source6;
 6664                this.source7 = source7;
 6665                this.source8 = source8;
 6666                this.source9 = source9;
 6667                this.source10 = source10;
 6668                this.source11 = source11;
 6669                this.source12 = source12;
 6670
 6671                this.resultSelector = resultSelector;
 6672                this.cancellationToken = cancellationToken;
 6673                TaskTracker.TrackActiveTask(this, 3);
 6674            }
 6675
 6676            public TResult Current => result;
 6677
 6678            public UniTask<bool> MoveNextAsync()
 6679            {
 6680                cancellationToken.ThrowIfCancellationRequested();
 6681                if (completedCount == CompleteCount) return CompletedTasks.False;
 6682
 6683                if (enumerator1 == null)
 6684                {
 6685                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 6686                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 6687                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 6688                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 6689                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 6690                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 6691                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 6692                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 6693                    enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
 6694                    enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
 6695                    enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
 6696                    enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
 6697                }
 6698
 6699                completionSource.Reset();
 6700
 6701                AGAIN:
 6702                syncRunning = true;
 6703                if (!running1)
 6704                {
 6705                    running1 = true;
 6706                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 6707                    if (awaiter1.IsCompleted)
 6708                    {
 6709                        Completed1(this);
 6710                    }
 6711                    else
 6712                    {
 6713                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 6714                    }
 6715                }
 6716                if (!running2)
 6717                {
 6718                    running2 = true;
 6719                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 6720                    if (awaiter2.IsCompleted)
 6721                    {
 6722                        Completed2(this);
 6723                    }
 6724                    else
 6725                    {
 6726                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 6727                    }
 6728                }
 6729                if (!running3)
 6730                {
 6731                    running3 = true;
 6732                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 6733                    if (awaiter3.IsCompleted)
 6734                    {
 6735                        Completed3(this);
 6736                    }
 6737                    else
 6738                    {
 6739                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 6740                    }
 6741                }
 6742                if (!running4)
 6743                {
 6744                    running4 = true;
 6745                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 6746                    if (awaiter4.IsCompleted)
 6747                    {
 6748                        Completed4(this);
 6749                    }
 6750                    else
 6751                    {
 6752                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 6753                    }
 6754                }
 6755                if (!running5)
 6756                {
 6757                    running5 = true;
 6758                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 6759                    if (awaiter5.IsCompleted)
 6760                    {
 6761                        Completed5(this);
 6762                    }
 6763                    else
 6764                    {
 6765                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 6766                    }
 6767                }
 6768                if (!running6)
 6769                {
 6770                    running6 = true;
 6771                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 6772                    if (awaiter6.IsCompleted)
 6773                    {
 6774                        Completed6(this);
 6775                    }
 6776                    else
 6777                    {
 6778                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 6779                    }
 6780                }
 6781                if (!running7)
 6782                {
 6783                    running7 = true;
 6784                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 6785                    if (awaiter7.IsCompleted)
 6786                    {
 6787                        Completed7(this);
 6788                    }
 6789                    else
 6790                    {
 6791                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 6792                    }
 6793                }
 6794                if (!running8)
 6795                {
 6796                    running8 = true;
 6797                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 6798                    if (awaiter8.IsCompleted)
 6799                    {
 6800                        Completed8(this);
 6801                    }
 6802                    else
 6803                    {
 6804                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 6805                    }
 6806                }
 6807                if (!running9)
 6808                {
 6809                    running9 = true;
 6810                    awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
 6811                    if (awaiter9.IsCompleted)
 6812                    {
 6813                        Completed9(this);
 6814                    }
 6815                    else
 6816                    {
 6817                        awaiter9.SourceOnCompleted(Completed9Delegate, this);
 6818                    }
 6819                }
 6820                if (!running10)
 6821                {
 6822                    running10 = true;
 6823                    awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
 6824                    if (awaiter10.IsCompleted)
 6825                    {
 6826                        Completed10(this);
 6827                    }
 6828                    else
 6829                    {
 6830                        awaiter10.SourceOnCompleted(Completed10Delegate, this);
 6831                    }
 6832                }
 6833                if (!running11)
 6834                {
 6835                    running11 = true;
 6836                    awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
 6837                    if (awaiter11.IsCompleted)
 6838                    {
 6839                        Completed11(this);
 6840                    }
 6841                    else
 6842                    {
 6843                        awaiter11.SourceOnCompleted(Completed11Delegate, this);
 6844                    }
 6845                }
 6846                if (!running12)
 6847                {
 6848                    running12 = true;
 6849                    awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
 6850                    if (awaiter12.IsCompleted)
 6851                    {
 6852                        Completed12(this);
 6853                    }
 6854                    else
 6855                    {
 6856                        awaiter12.SourceOnCompleted(Completed12Delegate, this);
 6857                    }
 6858                }
 6859
 6860                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 6861                {
 6862                    goto AGAIN;
 6863                }
 6864                syncRunning = false;
 6865
 6866                return new UniTask<bool>(this, completionSource.Version);
 6867            }
 6868
 6869            static void Completed1(object state)
 6870            {
 6871                var self = (_CombineLatest)state;
 6872                self.running1 = false;
 6873
 6874                try
 6875                {
 6876                    if (self.awaiter1.GetResult())
 6877                    {
 6878                        self.hasCurrent1 = true;
 6879                        self.current1 = self.enumerator1.Current;
 6880                        goto SUCCESS;
 6881                    }
 6882                    else
 6883                    {
 6884                        self.running1 = true; // as complete, no more call MoveNextAsync.
 6885                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6886                        {
 6887                            goto COMPLETE;
 6888                        }
 6889                        return;
 6890                    }
 6891                }
 6892                catch (Exception ex)
 6893                {
 6894                    self.running1 = true; // as complete, no more call MoveNextAsync.
 6895                    self.completedCount = CompleteCount;
 6896                    self.completionSource.TrySetException(ex);
 6897                    return;
 6898                }
 6899
 6900                SUCCESS:
 6901                if (!self.TrySetResult())
 6902                {
 6903                    if (self.syncRunning) return;
 6904                    self.running1 = true; // as complete, no more call MoveNextAsync.
 6905                    try
 6906                    {
 6907                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 6908                    }
 6909                    catch (Exception ex)
 6910                    {
 6911                        self.completedCount = CompleteCount;
 6912                        self.completionSource.TrySetException(ex);
 6913                        return;
 6914                    }
 6915
 6916                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 6917                }
 6918                return;
 6919                COMPLETE:
 6920                self.completionSource.TrySetResult(false);
 6921                return;
 6922            }
 6923
 6924            static void Completed2(object state)
 6925            {
 6926                var self = (_CombineLatest)state;
 6927                self.running2 = false;
 6928
 6929                try
 6930                {
 6931                    if (self.awaiter2.GetResult())
 6932                    {
 6933                        self.hasCurrent2 = true;
 6934                        self.current2 = self.enumerator2.Current;
 6935                        goto SUCCESS;
 6936                    }
 6937                    else
 6938                    {
 6939                        self.running2 = true; // as complete, no more call MoveNextAsync.
 6940                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6941                        {
 6942                            goto COMPLETE;
 6943                        }
 6944                        return;
 6945                    }
 6946                }
 6947                catch (Exception ex)
 6948                {
 6949                    self.running2 = true; // as complete, no more call MoveNextAsync.
 6950                    self.completedCount = CompleteCount;
 6951                    self.completionSource.TrySetException(ex);
 6952                    return;
 6953                }
 6954
 6955                SUCCESS:
 6956                if (!self.TrySetResult())
 6957                {
 6958                    if (self.syncRunning) return;
 6959                    self.running2 = true; // as complete, no more call MoveNextAsync.
 6960                    try
 6961                    {
 6962                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 6963                    }
 6964                    catch (Exception ex)
 6965                    {
 6966                        self.completedCount = CompleteCount;
 6967                        self.completionSource.TrySetException(ex);
 6968                        return;
 6969                    }
 6970
 6971                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 6972                }
 6973                return;
 6974                COMPLETE:
 6975                self.completionSource.TrySetResult(false);
 6976                return;
 6977            }
 6978
 6979            static void Completed3(object state)
 6980            {
 6981                var self = (_CombineLatest)state;
 6982                self.running3 = false;
 6983
 6984                try
 6985                {
 6986                    if (self.awaiter3.GetResult())
 6987                    {
 6988                        self.hasCurrent3 = true;
 6989                        self.current3 = self.enumerator3.Current;
 6990                        goto SUCCESS;
 6991                    }
 6992                    else
 6993                    {
 6994                        self.running3 = true; // as complete, no more call MoveNextAsync.
 6995                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 6996                        {
 6997                            goto COMPLETE;
 6998                        }
 6999                        return;
 7000                    }
 7001                }
 7002                catch (Exception ex)
 7003                {
 7004                    self.running3 = true; // as complete, no more call MoveNextAsync.
 7005                    self.completedCount = CompleteCount;
 7006                    self.completionSource.TrySetException(ex);
 7007                    return;
 7008                }
 7009
 7010                SUCCESS:
 7011                if (!self.TrySetResult())
 7012                {
 7013                    if (self.syncRunning) return;
 7014                    self.running3 = true; // as complete, no more call MoveNextAsync.
 7015                    try
 7016                    {
 7017                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 7018                    }
 7019                    catch (Exception ex)
 7020                    {
 7021                        self.completedCount = CompleteCount;
 7022                        self.completionSource.TrySetException(ex);
 7023                        return;
 7024                    }
 7025
 7026                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 7027                }
 7028                return;
 7029                COMPLETE:
 7030                self.completionSource.TrySetResult(false);
 7031                return;
 7032            }
 7033
 7034            static void Completed4(object state)
 7035            {
 7036                var self = (_CombineLatest)state;
 7037                self.running4 = false;
 7038
 7039                try
 7040                {
 7041                    if (self.awaiter4.GetResult())
 7042                    {
 7043                        self.hasCurrent4 = true;
 7044                        self.current4 = self.enumerator4.Current;
 7045                        goto SUCCESS;
 7046                    }
 7047                    else
 7048                    {
 7049                        self.running4 = true; // as complete, no more call MoveNextAsync.
 7050                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7051                        {
 7052                            goto COMPLETE;
 7053                        }
 7054                        return;
 7055                    }
 7056                }
 7057                catch (Exception ex)
 7058                {
 7059                    self.running4 = true; // as complete, no more call MoveNextAsync.
 7060                    self.completedCount = CompleteCount;
 7061                    self.completionSource.TrySetException(ex);
 7062                    return;
 7063                }
 7064
 7065                SUCCESS:
 7066                if (!self.TrySetResult())
 7067                {
 7068                    if (self.syncRunning) return;
 7069                    self.running4 = true; // as complete, no more call MoveNextAsync.
 7070                    try
 7071                    {
 7072                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 7073                    }
 7074                    catch (Exception ex)
 7075                    {
 7076                        self.completedCount = CompleteCount;
 7077                        self.completionSource.TrySetException(ex);
 7078                        return;
 7079                    }
 7080
 7081                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 7082                }
 7083                return;
 7084                COMPLETE:
 7085                self.completionSource.TrySetResult(false);
 7086                return;
 7087            }
 7088
 7089            static void Completed5(object state)
 7090            {
 7091                var self = (_CombineLatest)state;
 7092                self.running5 = false;
 7093
 7094                try
 7095                {
 7096                    if (self.awaiter5.GetResult())
 7097                    {
 7098                        self.hasCurrent5 = true;
 7099                        self.current5 = self.enumerator5.Current;
 7100                        goto SUCCESS;
 7101                    }
 7102                    else
 7103                    {
 7104                        self.running5 = true; // as complete, no more call MoveNextAsync.
 7105                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7106                        {
 7107                            goto COMPLETE;
 7108                        }
 7109                        return;
 7110                    }
 7111                }
 7112                catch (Exception ex)
 7113                {
 7114                    self.running5 = true; // as complete, no more call MoveNextAsync.
 7115                    self.completedCount = CompleteCount;
 7116                    self.completionSource.TrySetException(ex);
 7117                    return;
 7118                }
 7119
 7120                SUCCESS:
 7121                if (!self.TrySetResult())
 7122                {
 7123                    if (self.syncRunning) return;
 7124                    self.running5 = true; // as complete, no more call MoveNextAsync.
 7125                    try
 7126                    {
 7127                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 7128                    }
 7129                    catch (Exception ex)
 7130                    {
 7131                        self.completedCount = CompleteCount;
 7132                        self.completionSource.TrySetException(ex);
 7133                        return;
 7134                    }
 7135
 7136                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 7137                }
 7138                return;
 7139                COMPLETE:
 7140                self.completionSource.TrySetResult(false);
 7141                return;
 7142            }
 7143
 7144            static void Completed6(object state)
 7145            {
 7146                var self = (_CombineLatest)state;
 7147                self.running6 = false;
 7148
 7149                try
 7150                {
 7151                    if (self.awaiter6.GetResult())
 7152                    {
 7153                        self.hasCurrent6 = true;
 7154                        self.current6 = self.enumerator6.Current;
 7155                        goto SUCCESS;
 7156                    }
 7157                    else
 7158                    {
 7159                        self.running6 = true; // as complete, no more call MoveNextAsync.
 7160                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7161                        {
 7162                            goto COMPLETE;
 7163                        }
 7164                        return;
 7165                    }
 7166                }
 7167                catch (Exception ex)
 7168                {
 7169                    self.running6 = true; // as complete, no more call MoveNextAsync.
 7170                    self.completedCount = CompleteCount;
 7171                    self.completionSource.TrySetException(ex);
 7172                    return;
 7173                }
 7174
 7175                SUCCESS:
 7176                if (!self.TrySetResult())
 7177                {
 7178                    if (self.syncRunning) return;
 7179                    self.running6 = true; // as complete, no more call MoveNextAsync.
 7180                    try
 7181                    {
 7182                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 7183                    }
 7184                    catch (Exception ex)
 7185                    {
 7186                        self.completedCount = CompleteCount;
 7187                        self.completionSource.TrySetException(ex);
 7188                        return;
 7189                    }
 7190
 7191                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 7192                }
 7193                return;
 7194                COMPLETE:
 7195                self.completionSource.TrySetResult(false);
 7196                return;
 7197            }
 7198
 7199            static void Completed7(object state)
 7200            {
 7201                var self = (_CombineLatest)state;
 7202                self.running7 = false;
 7203
 7204                try
 7205                {
 7206                    if (self.awaiter7.GetResult())
 7207                    {
 7208                        self.hasCurrent7 = true;
 7209                        self.current7 = self.enumerator7.Current;
 7210                        goto SUCCESS;
 7211                    }
 7212                    else
 7213                    {
 7214                        self.running7 = true; // as complete, no more call MoveNextAsync.
 7215                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7216                        {
 7217                            goto COMPLETE;
 7218                        }
 7219                        return;
 7220                    }
 7221                }
 7222                catch (Exception ex)
 7223                {
 7224                    self.running7 = true; // as complete, no more call MoveNextAsync.
 7225                    self.completedCount = CompleteCount;
 7226                    self.completionSource.TrySetException(ex);
 7227                    return;
 7228                }
 7229
 7230                SUCCESS:
 7231                if (!self.TrySetResult())
 7232                {
 7233                    if (self.syncRunning) return;
 7234                    self.running7 = true; // as complete, no more call MoveNextAsync.
 7235                    try
 7236                    {
 7237                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 7238                    }
 7239                    catch (Exception ex)
 7240                    {
 7241                        self.completedCount = CompleteCount;
 7242                        self.completionSource.TrySetException(ex);
 7243                        return;
 7244                    }
 7245
 7246                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 7247                }
 7248                return;
 7249                COMPLETE:
 7250                self.completionSource.TrySetResult(false);
 7251                return;
 7252            }
 7253
 7254            static void Completed8(object state)
 7255            {
 7256                var self = (_CombineLatest)state;
 7257                self.running8 = false;
 7258
 7259                try
 7260                {
 7261                    if (self.awaiter8.GetResult())
 7262                    {
 7263                        self.hasCurrent8 = true;
 7264                        self.current8 = self.enumerator8.Current;
 7265                        goto SUCCESS;
 7266                    }
 7267                    else
 7268                    {
 7269                        self.running8 = true; // as complete, no more call MoveNextAsync.
 7270                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7271                        {
 7272                            goto COMPLETE;
 7273                        }
 7274                        return;
 7275                    }
 7276                }
 7277                catch (Exception ex)
 7278                {
 7279                    self.running8 = true; // as complete, no more call MoveNextAsync.
 7280                    self.completedCount = CompleteCount;
 7281                    self.completionSource.TrySetException(ex);
 7282                    return;
 7283                }
 7284
 7285                SUCCESS:
 7286                if (!self.TrySetResult())
 7287                {
 7288                    if (self.syncRunning) return;
 7289                    self.running8 = true; // as complete, no more call MoveNextAsync.
 7290                    try
 7291                    {
 7292                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 7293                    }
 7294                    catch (Exception ex)
 7295                    {
 7296                        self.completedCount = CompleteCount;
 7297                        self.completionSource.TrySetException(ex);
 7298                        return;
 7299                    }
 7300
 7301                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 7302                }
 7303                return;
 7304                COMPLETE:
 7305                self.completionSource.TrySetResult(false);
 7306                return;
 7307            }
 7308
 7309            static void Completed9(object state)
 7310            {
 7311                var self = (_CombineLatest)state;
 7312                self.running9 = false;
 7313
 7314                try
 7315                {
 7316                    if (self.awaiter9.GetResult())
 7317                    {
 7318                        self.hasCurrent9 = true;
 7319                        self.current9 = self.enumerator9.Current;
 7320                        goto SUCCESS;
 7321                    }
 7322                    else
 7323                    {
 7324                        self.running9 = true; // as complete, no more call MoveNextAsync.
 7325                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7326                        {
 7327                            goto COMPLETE;
 7328                        }
 7329                        return;
 7330                    }
 7331                }
 7332                catch (Exception ex)
 7333                {
 7334                    self.running9 = true; // as complete, no more call MoveNextAsync.
 7335                    self.completedCount = CompleteCount;
 7336                    self.completionSource.TrySetException(ex);
 7337                    return;
 7338                }
 7339
 7340                SUCCESS:
 7341                if (!self.TrySetResult())
 7342                {
 7343                    if (self.syncRunning) return;
 7344                    self.running9 = true; // as complete, no more call MoveNextAsync.
 7345                    try
 7346                    {
 7347                        self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter();
 7348                    }
 7349                    catch (Exception ex)
 7350                    {
 7351                        self.completedCount = CompleteCount;
 7352                        self.completionSource.TrySetException(ex);
 7353                        return;
 7354                    }
 7355
 7356                    self.awaiter9.SourceOnCompleted(Completed9Delegate, self);
 7357                }
 7358                return;
 7359                COMPLETE:
 7360                self.completionSource.TrySetResult(false);
 7361                return;
 7362            }
 7363
 7364            static void Completed10(object state)
 7365            {
 7366                var self = (_CombineLatest)state;
 7367                self.running10 = false;
 7368
 7369                try
 7370                {
 7371                    if (self.awaiter10.GetResult())
 7372                    {
 7373                        self.hasCurrent10 = true;
 7374                        self.current10 = self.enumerator10.Current;
 7375                        goto SUCCESS;
 7376                    }
 7377                    else
 7378                    {
 7379                        self.running10 = true; // as complete, no more call MoveNextAsync.
 7380                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7381                        {
 7382                            goto COMPLETE;
 7383                        }
 7384                        return;
 7385                    }
 7386                }
 7387                catch (Exception ex)
 7388                {
 7389                    self.running10 = true; // as complete, no more call MoveNextAsync.
 7390                    self.completedCount = CompleteCount;
 7391                    self.completionSource.TrySetException(ex);
 7392                    return;
 7393                }
 7394
 7395                SUCCESS:
 7396                if (!self.TrySetResult())
 7397                {
 7398                    if (self.syncRunning) return;
 7399                    self.running10 = true; // as complete, no more call MoveNextAsync.
 7400                    try
 7401                    {
 7402                        self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter();
 7403                    }
 7404                    catch (Exception ex)
 7405                    {
 7406                        self.completedCount = CompleteCount;
 7407                        self.completionSource.TrySetException(ex);
 7408                        return;
 7409                    }
 7410
 7411                    self.awaiter10.SourceOnCompleted(Completed10Delegate, self);
 7412                }
 7413                return;
 7414                COMPLETE:
 7415                self.completionSource.TrySetResult(false);
 7416                return;
 7417            }
 7418
 7419            static void Completed11(object state)
 7420            {
 7421                var self = (_CombineLatest)state;
 7422                self.running11 = false;
 7423
 7424                try
 7425                {
 7426                    if (self.awaiter11.GetResult())
 7427                    {
 7428                        self.hasCurrent11 = true;
 7429                        self.current11 = self.enumerator11.Current;
 7430                        goto SUCCESS;
 7431                    }
 7432                    else
 7433                    {
 7434                        self.running11 = true; // as complete, no more call MoveNextAsync.
 7435                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7436                        {
 7437                            goto COMPLETE;
 7438                        }
 7439                        return;
 7440                    }
 7441                }
 7442                catch (Exception ex)
 7443                {
 7444                    self.running11 = true; // as complete, no more call MoveNextAsync.
 7445                    self.completedCount = CompleteCount;
 7446                    self.completionSource.TrySetException(ex);
 7447                    return;
 7448                }
 7449
 7450                SUCCESS:
 7451                if (!self.TrySetResult())
 7452                {
 7453                    if (self.syncRunning) return;
 7454                    self.running11 = true; // as complete, no more call MoveNextAsync.
 7455                    try
 7456                    {
 7457                        self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter();
 7458                    }
 7459                    catch (Exception ex)
 7460                    {
 7461                        self.completedCount = CompleteCount;
 7462                        self.completionSource.TrySetException(ex);
 7463                        return;
 7464                    }
 7465
 7466                    self.awaiter11.SourceOnCompleted(Completed11Delegate, self);
 7467                }
 7468                return;
 7469                COMPLETE:
 7470                self.completionSource.TrySetResult(false);
 7471                return;
 7472            }
 7473
 7474            static void Completed12(object state)
 7475            {
 7476                var self = (_CombineLatest)state;
 7477                self.running12 = false;
 7478
 7479                try
 7480                {
 7481                    if (self.awaiter12.GetResult())
 7482                    {
 7483                        self.hasCurrent12 = true;
 7484                        self.current12 = self.enumerator12.Current;
 7485                        goto SUCCESS;
 7486                    }
 7487                    else
 7488                    {
 7489                        self.running12 = true; // as complete, no more call MoveNextAsync.
 7490                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 7491                        {
 7492                            goto COMPLETE;
 7493                        }
 7494                        return;
 7495                    }
 7496                }
 7497                catch (Exception ex)
 7498                {
 7499                    self.running12 = true; // as complete, no more call MoveNextAsync.
 7500                    self.completedCount = CompleteCount;
 7501                    self.completionSource.TrySetException(ex);
 7502                    return;
 7503                }
 7504
 7505                SUCCESS:
 7506                if (!self.TrySetResult())
 7507                {
 7508                    if (self.syncRunning) return;
 7509                    self.running12 = true; // as complete, no more call MoveNextAsync.
 7510                    try
 7511                    {
 7512                        self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter();
 7513                    }
 7514                    catch (Exception ex)
 7515                    {
 7516                        self.completedCount = CompleteCount;
 7517                        self.completionSource.TrySetException(ex);
 7518                        return;
 7519                    }
 7520
 7521                    self.awaiter12.SourceOnCompleted(Completed12Delegate, self);
 7522                }
 7523                return;
 7524                COMPLETE:
 7525                self.completionSource.TrySetResult(false);
 7526                return;
 7527            }
 7528
 7529            bool TrySetResult()
 7530            {
 7531                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 7532                {
 7533                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 7534                    completionSource.TrySetResult(true);
 7535                    return true;
 7536                }
 7537                else
 7538                {
 7539                    return false;
 7540                }
 7541            }
 7542
 7543            public async UniTask DisposeAsync()
 7544            {
 7545                TaskTracker.RemoveTracking(this);
 7546                if (enumerator1 != null)
 7547                {
 7548                    await enumerator1.DisposeAsync();
 7549                }
 7550                if (enumerator2 != null)
 7551                {
 7552                    await enumerator2.DisposeAsync();
 7553                }
 7554                if (enumerator3 != null)
 7555                {
 7556                    await enumerator3.DisposeAsync();
 7557                }
 7558                if (enumerator4 != null)
 7559                {
 7560                    await enumerator4.DisposeAsync();
 7561                }
 7562                if (enumerator5 != null)
 7563                {
 7564                    await enumerator5.DisposeAsync();
 7565                }
 7566                if (enumerator6 != null)
 7567                {
 7568                    await enumerator6.DisposeAsync();
 7569                }
 7570                if (enumerator7 != null)
 7571                {
 7572                    await enumerator7.DisposeAsync();
 7573                }
 7574                if (enumerator8 != null)
 7575                {
 7576                    await enumerator8.DisposeAsync();
 7577                }
 7578                if (enumerator9 != null)
 7579                {
 7580                    await enumerator9.DisposeAsync();
 7581                }
 7582                if (enumerator10 != null)
 7583                {
 7584                    await enumerator10.DisposeAsync();
 7585                }
 7586                if (enumerator11 != null)
 7587                {
 7588                    await enumerator11.DisposeAsync();
 7589                }
 7590                if (enumerator12 != null)
 7591                {
 7592                    await enumerator12.DisposeAsync();
 7593                }
 7594            }
 7595        }
 7596    }
 7597
 7598    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> : IUniTaskAsyncEnumera
 7599    {
 7600        readonly IUniTaskAsyncEnumerable<T1> source1;
 7601        readonly IUniTaskAsyncEnumerable<T2> source2;
 7602        readonly IUniTaskAsyncEnumerable<T3> source3;
 7603        readonly IUniTaskAsyncEnumerable<T4> source4;
 7604        readonly IUniTaskAsyncEnumerable<T5> source5;
 7605        readonly IUniTaskAsyncEnumerable<T6> source6;
 7606        readonly IUniTaskAsyncEnumerable<T7> source7;
 7607        readonly IUniTaskAsyncEnumerable<T8> source8;
 7608        readonly IUniTaskAsyncEnumerable<T9> source9;
 7609        readonly IUniTaskAsyncEnumerable<T10> source10;
 7610        readonly IUniTaskAsyncEnumerable<T11> source11;
 7611        readonly IUniTaskAsyncEnumerable<T12> source12;
 7612        readonly IUniTaskAsyncEnumerable<T13> source13;
 7613
 7614        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector;
 7615
 7616        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 7617        {
 7618            this.source1 = source1;
 7619            this.source2 = source2;
 7620            this.source3 = source3;
 7621            this.source4 = source4;
 7622            this.source5 = source5;
 7623            this.source6 = source6;
 7624            this.source7 = source7;
 7625            this.source8 = source8;
 7626            this.source9 = source9;
 7627            this.source10 = source10;
 7628            this.source11 = source11;
 7629            this.source12 = source12;
 7630            this.source13 = source13;
 7631
 7632            this.resultSelector = resultSelector;
 7633        }
 7634
 7635        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 7636        {
 7637            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, s
 7638        }
 7639
 7640        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 7641        {
 7642            static readonly Action<object> Completed1Delegate = Completed1;
 7643            static readonly Action<object> Completed2Delegate = Completed2;
 7644            static readonly Action<object> Completed3Delegate = Completed3;
 7645            static readonly Action<object> Completed4Delegate = Completed4;
 7646            static readonly Action<object> Completed5Delegate = Completed5;
 7647            static readonly Action<object> Completed6Delegate = Completed6;
 7648            static readonly Action<object> Completed7Delegate = Completed7;
 7649            static readonly Action<object> Completed8Delegate = Completed8;
 7650            static readonly Action<object> Completed9Delegate = Completed9;
 7651            static readonly Action<object> Completed10Delegate = Completed10;
 7652            static readonly Action<object> Completed11Delegate = Completed11;
 7653            static readonly Action<object> Completed12Delegate = Completed12;
 7654            static readonly Action<object> Completed13Delegate = Completed13;
 7655            const int CompleteCount = 13;
 7656
 7657            readonly IUniTaskAsyncEnumerable<T1> source1;
 7658            readonly IUniTaskAsyncEnumerable<T2> source2;
 7659            readonly IUniTaskAsyncEnumerable<T3> source3;
 7660            readonly IUniTaskAsyncEnumerable<T4> source4;
 7661            readonly IUniTaskAsyncEnumerable<T5> source5;
 7662            readonly IUniTaskAsyncEnumerable<T6> source6;
 7663            readonly IUniTaskAsyncEnumerable<T7> source7;
 7664            readonly IUniTaskAsyncEnumerable<T8> source8;
 7665            readonly IUniTaskAsyncEnumerable<T9> source9;
 7666            readonly IUniTaskAsyncEnumerable<T10> source10;
 7667            readonly IUniTaskAsyncEnumerable<T11> source11;
 7668            readonly IUniTaskAsyncEnumerable<T12> source12;
 7669            readonly IUniTaskAsyncEnumerable<T13> source13;
 7670
 7671            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector;
 7672            CancellationToken cancellationToken;
 7673
 7674            IUniTaskAsyncEnumerator<T1> enumerator1;
 7675            UniTask<bool>.Awaiter awaiter1;
 7676            bool hasCurrent1;
 7677            bool running1;
 7678            T1 current1;
 7679
 7680            IUniTaskAsyncEnumerator<T2> enumerator2;
 7681            UniTask<bool>.Awaiter awaiter2;
 7682            bool hasCurrent2;
 7683            bool running2;
 7684            T2 current2;
 7685
 7686            IUniTaskAsyncEnumerator<T3> enumerator3;
 7687            UniTask<bool>.Awaiter awaiter3;
 7688            bool hasCurrent3;
 7689            bool running3;
 7690            T3 current3;
 7691
 7692            IUniTaskAsyncEnumerator<T4> enumerator4;
 7693            UniTask<bool>.Awaiter awaiter4;
 7694            bool hasCurrent4;
 7695            bool running4;
 7696            T4 current4;
 7697
 7698            IUniTaskAsyncEnumerator<T5> enumerator5;
 7699            UniTask<bool>.Awaiter awaiter5;
 7700            bool hasCurrent5;
 7701            bool running5;
 7702            T5 current5;
 7703
 7704            IUniTaskAsyncEnumerator<T6> enumerator6;
 7705            UniTask<bool>.Awaiter awaiter6;
 7706            bool hasCurrent6;
 7707            bool running6;
 7708            T6 current6;
 7709
 7710            IUniTaskAsyncEnumerator<T7> enumerator7;
 7711            UniTask<bool>.Awaiter awaiter7;
 7712            bool hasCurrent7;
 7713            bool running7;
 7714            T7 current7;
 7715
 7716            IUniTaskAsyncEnumerator<T8> enumerator8;
 7717            UniTask<bool>.Awaiter awaiter8;
 7718            bool hasCurrent8;
 7719            bool running8;
 7720            T8 current8;
 7721
 7722            IUniTaskAsyncEnumerator<T9> enumerator9;
 7723            UniTask<bool>.Awaiter awaiter9;
 7724            bool hasCurrent9;
 7725            bool running9;
 7726            T9 current9;
 7727
 7728            IUniTaskAsyncEnumerator<T10> enumerator10;
 7729            UniTask<bool>.Awaiter awaiter10;
 7730            bool hasCurrent10;
 7731            bool running10;
 7732            T10 current10;
 7733
 7734            IUniTaskAsyncEnumerator<T11> enumerator11;
 7735            UniTask<bool>.Awaiter awaiter11;
 7736            bool hasCurrent11;
 7737            bool running11;
 7738            T11 current11;
 7739
 7740            IUniTaskAsyncEnumerator<T12> enumerator12;
 7741            UniTask<bool>.Awaiter awaiter12;
 7742            bool hasCurrent12;
 7743            bool running12;
 7744            T12 current12;
 7745
 7746            IUniTaskAsyncEnumerator<T13> enumerator13;
 7747            UniTask<bool>.Awaiter awaiter13;
 7748            bool hasCurrent13;
 7749            bool running13;
 7750            T13 current13;
 7751
 7752            int completedCount;
 7753            bool syncRunning;
 7754            TResult result;
 7755
 7756            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 7757            {
 7758                this.source1 = source1;
 7759                this.source2 = source2;
 7760                this.source3 = source3;
 7761                this.source4 = source4;
 7762                this.source5 = source5;
 7763                this.source6 = source6;
 7764                this.source7 = source7;
 7765                this.source8 = source8;
 7766                this.source9 = source9;
 7767                this.source10 = source10;
 7768                this.source11 = source11;
 7769                this.source12 = source12;
 7770                this.source13 = source13;
 7771
 7772                this.resultSelector = resultSelector;
 7773                this.cancellationToken = cancellationToken;
 7774                TaskTracker.TrackActiveTask(this, 3);
 7775            }
 7776
 7777            public TResult Current => result;
 7778
 7779            public UniTask<bool> MoveNextAsync()
 7780            {
 7781                cancellationToken.ThrowIfCancellationRequested();
 7782                if (completedCount == CompleteCount) return CompletedTasks.False;
 7783
 7784                if (enumerator1 == null)
 7785                {
 7786                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 7787                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 7788                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 7789                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 7790                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 7791                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 7792                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 7793                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 7794                    enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
 7795                    enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
 7796                    enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
 7797                    enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
 7798                    enumerator13 = source13.GetAsyncEnumerator(cancellationToken);
 7799                }
 7800
 7801                completionSource.Reset();
 7802
 7803                AGAIN:
 7804                syncRunning = true;
 7805                if (!running1)
 7806                {
 7807                    running1 = true;
 7808                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 7809                    if (awaiter1.IsCompleted)
 7810                    {
 7811                        Completed1(this);
 7812                    }
 7813                    else
 7814                    {
 7815                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 7816                    }
 7817                }
 7818                if (!running2)
 7819                {
 7820                    running2 = true;
 7821                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 7822                    if (awaiter2.IsCompleted)
 7823                    {
 7824                        Completed2(this);
 7825                    }
 7826                    else
 7827                    {
 7828                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 7829                    }
 7830                }
 7831                if (!running3)
 7832                {
 7833                    running3 = true;
 7834                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 7835                    if (awaiter3.IsCompleted)
 7836                    {
 7837                        Completed3(this);
 7838                    }
 7839                    else
 7840                    {
 7841                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 7842                    }
 7843                }
 7844                if (!running4)
 7845                {
 7846                    running4 = true;
 7847                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 7848                    if (awaiter4.IsCompleted)
 7849                    {
 7850                        Completed4(this);
 7851                    }
 7852                    else
 7853                    {
 7854                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 7855                    }
 7856                }
 7857                if (!running5)
 7858                {
 7859                    running5 = true;
 7860                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 7861                    if (awaiter5.IsCompleted)
 7862                    {
 7863                        Completed5(this);
 7864                    }
 7865                    else
 7866                    {
 7867                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 7868                    }
 7869                }
 7870                if (!running6)
 7871                {
 7872                    running6 = true;
 7873                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 7874                    if (awaiter6.IsCompleted)
 7875                    {
 7876                        Completed6(this);
 7877                    }
 7878                    else
 7879                    {
 7880                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 7881                    }
 7882                }
 7883                if (!running7)
 7884                {
 7885                    running7 = true;
 7886                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 7887                    if (awaiter7.IsCompleted)
 7888                    {
 7889                        Completed7(this);
 7890                    }
 7891                    else
 7892                    {
 7893                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 7894                    }
 7895                }
 7896                if (!running8)
 7897                {
 7898                    running8 = true;
 7899                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 7900                    if (awaiter8.IsCompleted)
 7901                    {
 7902                        Completed8(this);
 7903                    }
 7904                    else
 7905                    {
 7906                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 7907                    }
 7908                }
 7909                if (!running9)
 7910                {
 7911                    running9 = true;
 7912                    awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
 7913                    if (awaiter9.IsCompleted)
 7914                    {
 7915                        Completed9(this);
 7916                    }
 7917                    else
 7918                    {
 7919                        awaiter9.SourceOnCompleted(Completed9Delegate, this);
 7920                    }
 7921                }
 7922                if (!running10)
 7923                {
 7924                    running10 = true;
 7925                    awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
 7926                    if (awaiter10.IsCompleted)
 7927                    {
 7928                        Completed10(this);
 7929                    }
 7930                    else
 7931                    {
 7932                        awaiter10.SourceOnCompleted(Completed10Delegate, this);
 7933                    }
 7934                }
 7935                if (!running11)
 7936                {
 7937                    running11 = true;
 7938                    awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
 7939                    if (awaiter11.IsCompleted)
 7940                    {
 7941                        Completed11(this);
 7942                    }
 7943                    else
 7944                    {
 7945                        awaiter11.SourceOnCompleted(Completed11Delegate, this);
 7946                    }
 7947                }
 7948                if (!running12)
 7949                {
 7950                    running12 = true;
 7951                    awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
 7952                    if (awaiter12.IsCompleted)
 7953                    {
 7954                        Completed12(this);
 7955                    }
 7956                    else
 7957                    {
 7958                        awaiter12.SourceOnCompleted(Completed12Delegate, this);
 7959                    }
 7960                }
 7961                if (!running13)
 7962                {
 7963                    running13 = true;
 7964                    awaiter13 = enumerator13.MoveNextAsync().GetAwaiter();
 7965                    if (awaiter13.IsCompleted)
 7966                    {
 7967                        Completed13(this);
 7968                    }
 7969                    else
 7970                    {
 7971                        awaiter13.SourceOnCompleted(Completed13Delegate, this);
 7972                    }
 7973                }
 7974
 7975                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 7976                {
 7977                    goto AGAIN;
 7978                }
 7979                syncRunning = false;
 7980
 7981                return new UniTask<bool>(this, completionSource.Version);
 7982            }
 7983
 7984            static void Completed1(object state)
 7985            {
 7986                var self = (_CombineLatest)state;
 7987                self.running1 = false;
 7988
 7989                try
 7990                {
 7991                    if (self.awaiter1.GetResult())
 7992                    {
 7993                        self.hasCurrent1 = true;
 7994                        self.current1 = self.enumerator1.Current;
 7995                        goto SUCCESS;
 7996                    }
 7997                    else
 7998                    {
 7999                        self.running1 = true; // as complete, no more call MoveNextAsync.
 8000                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8001                        {
 8002                            goto COMPLETE;
 8003                        }
 8004                        return;
 8005                    }
 8006                }
 8007                catch (Exception ex)
 8008                {
 8009                    self.running1 = true; // as complete, no more call MoveNextAsync.
 8010                    self.completedCount = CompleteCount;
 8011                    self.completionSource.TrySetException(ex);
 8012                    return;
 8013                }
 8014
 8015                SUCCESS:
 8016                if (!self.TrySetResult())
 8017                {
 8018                    if (self.syncRunning) return;
 8019                    self.running1 = true; // as complete, no more call MoveNextAsync.
 8020                    try
 8021                    {
 8022                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 8023                    }
 8024                    catch (Exception ex)
 8025                    {
 8026                        self.completedCount = CompleteCount;
 8027                        self.completionSource.TrySetException(ex);
 8028                        return;
 8029                    }
 8030
 8031                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 8032                }
 8033                return;
 8034                COMPLETE:
 8035                self.completionSource.TrySetResult(false);
 8036                return;
 8037            }
 8038
 8039            static void Completed2(object state)
 8040            {
 8041                var self = (_CombineLatest)state;
 8042                self.running2 = false;
 8043
 8044                try
 8045                {
 8046                    if (self.awaiter2.GetResult())
 8047                    {
 8048                        self.hasCurrent2 = true;
 8049                        self.current2 = self.enumerator2.Current;
 8050                        goto SUCCESS;
 8051                    }
 8052                    else
 8053                    {
 8054                        self.running2 = true; // as complete, no more call MoveNextAsync.
 8055                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8056                        {
 8057                            goto COMPLETE;
 8058                        }
 8059                        return;
 8060                    }
 8061                }
 8062                catch (Exception ex)
 8063                {
 8064                    self.running2 = true; // as complete, no more call MoveNextAsync.
 8065                    self.completedCount = CompleteCount;
 8066                    self.completionSource.TrySetException(ex);
 8067                    return;
 8068                }
 8069
 8070                SUCCESS:
 8071                if (!self.TrySetResult())
 8072                {
 8073                    if (self.syncRunning) return;
 8074                    self.running2 = true; // as complete, no more call MoveNextAsync.
 8075                    try
 8076                    {
 8077                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 8078                    }
 8079                    catch (Exception ex)
 8080                    {
 8081                        self.completedCount = CompleteCount;
 8082                        self.completionSource.TrySetException(ex);
 8083                        return;
 8084                    }
 8085
 8086                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 8087                }
 8088                return;
 8089                COMPLETE:
 8090                self.completionSource.TrySetResult(false);
 8091                return;
 8092            }
 8093
 8094            static void Completed3(object state)
 8095            {
 8096                var self = (_CombineLatest)state;
 8097                self.running3 = false;
 8098
 8099                try
 8100                {
 8101                    if (self.awaiter3.GetResult())
 8102                    {
 8103                        self.hasCurrent3 = true;
 8104                        self.current3 = self.enumerator3.Current;
 8105                        goto SUCCESS;
 8106                    }
 8107                    else
 8108                    {
 8109                        self.running3 = true; // as complete, no more call MoveNextAsync.
 8110                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8111                        {
 8112                            goto COMPLETE;
 8113                        }
 8114                        return;
 8115                    }
 8116                }
 8117                catch (Exception ex)
 8118                {
 8119                    self.running3 = true; // as complete, no more call MoveNextAsync.
 8120                    self.completedCount = CompleteCount;
 8121                    self.completionSource.TrySetException(ex);
 8122                    return;
 8123                }
 8124
 8125                SUCCESS:
 8126                if (!self.TrySetResult())
 8127                {
 8128                    if (self.syncRunning) return;
 8129                    self.running3 = true; // as complete, no more call MoveNextAsync.
 8130                    try
 8131                    {
 8132                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 8133                    }
 8134                    catch (Exception ex)
 8135                    {
 8136                        self.completedCount = CompleteCount;
 8137                        self.completionSource.TrySetException(ex);
 8138                        return;
 8139                    }
 8140
 8141                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 8142                }
 8143                return;
 8144                COMPLETE:
 8145                self.completionSource.TrySetResult(false);
 8146                return;
 8147            }
 8148
 8149            static void Completed4(object state)
 8150            {
 8151                var self = (_CombineLatest)state;
 8152                self.running4 = false;
 8153
 8154                try
 8155                {
 8156                    if (self.awaiter4.GetResult())
 8157                    {
 8158                        self.hasCurrent4 = true;
 8159                        self.current4 = self.enumerator4.Current;
 8160                        goto SUCCESS;
 8161                    }
 8162                    else
 8163                    {
 8164                        self.running4 = true; // as complete, no more call MoveNextAsync.
 8165                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8166                        {
 8167                            goto COMPLETE;
 8168                        }
 8169                        return;
 8170                    }
 8171                }
 8172                catch (Exception ex)
 8173                {
 8174                    self.running4 = true; // as complete, no more call MoveNextAsync.
 8175                    self.completedCount = CompleteCount;
 8176                    self.completionSource.TrySetException(ex);
 8177                    return;
 8178                }
 8179
 8180                SUCCESS:
 8181                if (!self.TrySetResult())
 8182                {
 8183                    if (self.syncRunning) return;
 8184                    self.running4 = true; // as complete, no more call MoveNextAsync.
 8185                    try
 8186                    {
 8187                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 8188                    }
 8189                    catch (Exception ex)
 8190                    {
 8191                        self.completedCount = CompleteCount;
 8192                        self.completionSource.TrySetException(ex);
 8193                        return;
 8194                    }
 8195
 8196                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 8197                }
 8198                return;
 8199                COMPLETE:
 8200                self.completionSource.TrySetResult(false);
 8201                return;
 8202            }
 8203
 8204            static void Completed5(object state)
 8205            {
 8206                var self = (_CombineLatest)state;
 8207                self.running5 = false;
 8208
 8209                try
 8210                {
 8211                    if (self.awaiter5.GetResult())
 8212                    {
 8213                        self.hasCurrent5 = true;
 8214                        self.current5 = self.enumerator5.Current;
 8215                        goto SUCCESS;
 8216                    }
 8217                    else
 8218                    {
 8219                        self.running5 = true; // as complete, no more call MoveNextAsync.
 8220                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8221                        {
 8222                            goto COMPLETE;
 8223                        }
 8224                        return;
 8225                    }
 8226                }
 8227                catch (Exception ex)
 8228                {
 8229                    self.running5 = true; // as complete, no more call MoveNextAsync.
 8230                    self.completedCount = CompleteCount;
 8231                    self.completionSource.TrySetException(ex);
 8232                    return;
 8233                }
 8234
 8235                SUCCESS:
 8236                if (!self.TrySetResult())
 8237                {
 8238                    if (self.syncRunning) return;
 8239                    self.running5 = true; // as complete, no more call MoveNextAsync.
 8240                    try
 8241                    {
 8242                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 8243                    }
 8244                    catch (Exception ex)
 8245                    {
 8246                        self.completedCount = CompleteCount;
 8247                        self.completionSource.TrySetException(ex);
 8248                        return;
 8249                    }
 8250
 8251                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 8252                }
 8253                return;
 8254                COMPLETE:
 8255                self.completionSource.TrySetResult(false);
 8256                return;
 8257            }
 8258
 8259            static void Completed6(object state)
 8260            {
 8261                var self = (_CombineLatest)state;
 8262                self.running6 = false;
 8263
 8264                try
 8265                {
 8266                    if (self.awaiter6.GetResult())
 8267                    {
 8268                        self.hasCurrent6 = true;
 8269                        self.current6 = self.enumerator6.Current;
 8270                        goto SUCCESS;
 8271                    }
 8272                    else
 8273                    {
 8274                        self.running6 = true; // as complete, no more call MoveNextAsync.
 8275                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8276                        {
 8277                            goto COMPLETE;
 8278                        }
 8279                        return;
 8280                    }
 8281                }
 8282                catch (Exception ex)
 8283                {
 8284                    self.running6 = true; // as complete, no more call MoveNextAsync.
 8285                    self.completedCount = CompleteCount;
 8286                    self.completionSource.TrySetException(ex);
 8287                    return;
 8288                }
 8289
 8290                SUCCESS:
 8291                if (!self.TrySetResult())
 8292                {
 8293                    if (self.syncRunning) return;
 8294                    self.running6 = true; // as complete, no more call MoveNextAsync.
 8295                    try
 8296                    {
 8297                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 8298                    }
 8299                    catch (Exception ex)
 8300                    {
 8301                        self.completedCount = CompleteCount;
 8302                        self.completionSource.TrySetException(ex);
 8303                        return;
 8304                    }
 8305
 8306                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 8307                }
 8308                return;
 8309                COMPLETE:
 8310                self.completionSource.TrySetResult(false);
 8311                return;
 8312            }
 8313
 8314            static void Completed7(object state)
 8315            {
 8316                var self = (_CombineLatest)state;
 8317                self.running7 = false;
 8318
 8319                try
 8320                {
 8321                    if (self.awaiter7.GetResult())
 8322                    {
 8323                        self.hasCurrent7 = true;
 8324                        self.current7 = self.enumerator7.Current;
 8325                        goto SUCCESS;
 8326                    }
 8327                    else
 8328                    {
 8329                        self.running7 = true; // as complete, no more call MoveNextAsync.
 8330                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8331                        {
 8332                            goto COMPLETE;
 8333                        }
 8334                        return;
 8335                    }
 8336                }
 8337                catch (Exception ex)
 8338                {
 8339                    self.running7 = true; // as complete, no more call MoveNextAsync.
 8340                    self.completedCount = CompleteCount;
 8341                    self.completionSource.TrySetException(ex);
 8342                    return;
 8343                }
 8344
 8345                SUCCESS:
 8346                if (!self.TrySetResult())
 8347                {
 8348                    if (self.syncRunning) return;
 8349                    self.running7 = true; // as complete, no more call MoveNextAsync.
 8350                    try
 8351                    {
 8352                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 8353                    }
 8354                    catch (Exception ex)
 8355                    {
 8356                        self.completedCount = CompleteCount;
 8357                        self.completionSource.TrySetException(ex);
 8358                        return;
 8359                    }
 8360
 8361                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 8362                }
 8363                return;
 8364                COMPLETE:
 8365                self.completionSource.TrySetResult(false);
 8366                return;
 8367            }
 8368
 8369            static void Completed8(object state)
 8370            {
 8371                var self = (_CombineLatest)state;
 8372                self.running8 = false;
 8373
 8374                try
 8375                {
 8376                    if (self.awaiter8.GetResult())
 8377                    {
 8378                        self.hasCurrent8 = true;
 8379                        self.current8 = self.enumerator8.Current;
 8380                        goto SUCCESS;
 8381                    }
 8382                    else
 8383                    {
 8384                        self.running8 = true; // as complete, no more call MoveNextAsync.
 8385                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8386                        {
 8387                            goto COMPLETE;
 8388                        }
 8389                        return;
 8390                    }
 8391                }
 8392                catch (Exception ex)
 8393                {
 8394                    self.running8 = true; // as complete, no more call MoveNextAsync.
 8395                    self.completedCount = CompleteCount;
 8396                    self.completionSource.TrySetException(ex);
 8397                    return;
 8398                }
 8399
 8400                SUCCESS:
 8401                if (!self.TrySetResult())
 8402                {
 8403                    if (self.syncRunning) return;
 8404                    self.running8 = true; // as complete, no more call MoveNextAsync.
 8405                    try
 8406                    {
 8407                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 8408                    }
 8409                    catch (Exception ex)
 8410                    {
 8411                        self.completedCount = CompleteCount;
 8412                        self.completionSource.TrySetException(ex);
 8413                        return;
 8414                    }
 8415
 8416                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 8417                }
 8418                return;
 8419                COMPLETE:
 8420                self.completionSource.TrySetResult(false);
 8421                return;
 8422            }
 8423
 8424            static void Completed9(object state)
 8425            {
 8426                var self = (_CombineLatest)state;
 8427                self.running9 = false;
 8428
 8429                try
 8430                {
 8431                    if (self.awaiter9.GetResult())
 8432                    {
 8433                        self.hasCurrent9 = true;
 8434                        self.current9 = self.enumerator9.Current;
 8435                        goto SUCCESS;
 8436                    }
 8437                    else
 8438                    {
 8439                        self.running9 = true; // as complete, no more call MoveNextAsync.
 8440                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8441                        {
 8442                            goto COMPLETE;
 8443                        }
 8444                        return;
 8445                    }
 8446                }
 8447                catch (Exception ex)
 8448                {
 8449                    self.running9 = true; // as complete, no more call MoveNextAsync.
 8450                    self.completedCount = CompleteCount;
 8451                    self.completionSource.TrySetException(ex);
 8452                    return;
 8453                }
 8454
 8455                SUCCESS:
 8456                if (!self.TrySetResult())
 8457                {
 8458                    if (self.syncRunning) return;
 8459                    self.running9 = true; // as complete, no more call MoveNextAsync.
 8460                    try
 8461                    {
 8462                        self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter();
 8463                    }
 8464                    catch (Exception ex)
 8465                    {
 8466                        self.completedCount = CompleteCount;
 8467                        self.completionSource.TrySetException(ex);
 8468                        return;
 8469                    }
 8470
 8471                    self.awaiter9.SourceOnCompleted(Completed9Delegate, self);
 8472                }
 8473                return;
 8474                COMPLETE:
 8475                self.completionSource.TrySetResult(false);
 8476                return;
 8477            }
 8478
 8479            static void Completed10(object state)
 8480            {
 8481                var self = (_CombineLatest)state;
 8482                self.running10 = false;
 8483
 8484                try
 8485                {
 8486                    if (self.awaiter10.GetResult())
 8487                    {
 8488                        self.hasCurrent10 = true;
 8489                        self.current10 = self.enumerator10.Current;
 8490                        goto SUCCESS;
 8491                    }
 8492                    else
 8493                    {
 8494                        self.running10 = true; // as complete, no more call MoveNextAsync.
 8495                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8496                        {
 8497                            goto COMPLETE;
 8498                        }
 8499                        return;
 8500                    }
 8501                }
 8502                catch (Exception ex)
 8503                {
 8504                    self.running10 = true; // as complete, no more call MoveNextAsync.
 8505                    self.completedCount = CompleteCount;
 8506                    self.completionSource.TrySetException(ex);
 8507                    return;
 8508                }
 8509
 8510                SUCCESS:
 8511                if (!self.TrySetResult())
 8512                {
 8513                    if (self.syncRunning) return;
 8514                    self.running10 = true; // as complete, no more call MoveNextAsync.
 8515                    try
 8516                    {
 8517                        self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter();
 8518                    }
 8519                    catch (Exception ex)
 8520                    {
 8521                        self.completedCount = CompleteCount;
 8522                        self.completionSource.TrySetException(ex);
 8523                        return;
 8524                    }
 8525
 8526                    self.awaiter10.SourceOnCompleted(Completed10Delegate, self);
 8527                }
 8528                return;
 8529                COMPLETE:
 8530                self.completionSource.TrySetResult(false);
 8531                return;
 8532            }
 8533
 8534            static void Completed11(object state)
 8535            {
 8536                var self = (_CombineLatest)state;
 8537                self.running11 = false;
 8538
 8539                try
 8540                {
 8541                    if (self.awaiter11.GetResult())
 8542                    {
 8543                        self.hasCurrent11 = true;
 8544                        self.current11 = self.enumerator11.Current;
 8545                        goto SUCCESS;
 8546                    }
 8547                    else
 8548                    {
 8549                        self.running11 = true; // as complete, no more call MoveNextAsync.
 8550                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8551                        {
 8552                            goto COMPLETE;
 8553                        }
 8554                        return;
 8555                    }
 8556                }
 8557                catch (Exception ex)
 8558                {
 8559                    self.running11 = true; // as complete, no more call MoveNextAsync.
 8560                    self.completedCount = CompleteCount;
 8561                    self.completionSource.TrySetException(ex);
 8562                    return;
 8563                }
 8564
 8565                SUCCESS:
 8566                if (!self.TrySetResult())
 8567                {
 8568                    if (self.syncRunning) return;
 8569                    self.running11 = true; // as complete, no more call MoveNextAsync.
 8570                    try
 8571                    {
 8572                        self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter();
 8573                    }
 8574                    catch (Exception ex)
 8575                    {
 8576                        self.completedCount = CompleteCount;
 8577                        self.completionSource.TrySetException(ex);
 8578                        return;
 8579                    }
 8580
 8581                    self.awaiter11.SourceOnCompleted(Completed11Delegate, self);
 8582                }
 8583                return;
 8584                COMPLETE:
 8585                self.completionSource.TrySetResult(false);
 8586                return;
 8587            }
 8588
 8589            static void Completed12(object state)
 8590            {
 8591                var self = (_CombineLatest)state;
 8592                self.running12 = false;
 8593
 8594                try
 8595                {
 8596                    if (self.awaiter12.GetResult())
 8597                    {
 8598                        self.hasCurrent12 = true;
 8599                        self.current12 = self.enumerator12.Current;
 8600                        goto SUCCESS;
 8601                    }
 8602                    else
 8603                    {
 8604                        self.running12 = true; // as complete, no more call MoveNextAsync.
 8605                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8606                        {
 8607                            goto COMPLETE;
 8608                        }
 8609                        return;
 8610                    }
 8611                }
 8612                catch (Exception ex)
 8613                {
 8614                    self.running12 = true; // as complete, no more call MoveNextAsync.
 8615                    self.completedCount = CompleteCount;
 8616                    self.completionSource.TrySetException(ex);
 8617                    return;
 8618                }
 8619
 8620                SUCCESS:
 8621                if (!self.TrySetResult())
 8622                {
 8623                    if (self.syncRunning) return;
 8624                    self.running12 = true; // as complete, no more call MoveNextAsync.
 8625                    try
 8626                    {
 8627                        self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter();
 8628                    }
 8629                    catch (Exception ex)
 8630                    {
 8631                        self.completedCount = CompleteCount;
 8632                        self.completionSource.TrySetException(ex);
 8633                        return;
 8634                    }
 8635
 8636                    self.awaiter12.SourceOnCompleted(Completed12Delegate, self);
 8637                }
 8638                return;
 8639                COMPLETE:
 8640                self.completionSource.TrySetResult(false);
 8641                return;
 8642            }
 8643
 8644            static void Completed13(object state)
 8645            {
 8646                var self = (_CombineLatest)state;
 8647                self.running13 = false;
 8648
 8649                try
 8650                {
 8651                    if (self.awaiter13.GetResult())
 8652                    {
 8653                        self.hasCurrent13 = true;
 8654                        self.current13 = self.enumerator13.Current;
 8655                        goto SUCCESS;
 8656                    }
 8657                    else
 8658                    {
 8659                        self.running13 = true; // as complete, no more call MoveNextAsync.
 8660                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 8661                        {
 8662                            goto COMPLETE;
 8663                        }
 8664                        return;
 8665                    }
 8666                }
 8667                catch (Exception ex)
 8668                {
 8669                    self.running13 = true; // as complete, no more call MoveNextAsync.
 8670                    self.completedCount = CompleteCount;
 8671                    self.completionSource.TrySetException(ex);
 8672                    return;
 8673                }
 8674
 8675                SUCCESS:
 8676                if (!self.TrySetResult())
 8677                {
 8678                    if (self.syncRunning) return;
 8679                    self.running13 = true; // as complete, no more call MoveNextAsync.
 8680                    try
 8681                    {
 8682                        self.awaiter13 = self.enumerator13.MoveNextAsync().GetAwaiter();
 8683                    }
 8684                    catch (Exception ex)
 8685                    {
 8686                        self.completedCount = CompleteCount;
 8687                        self.completionSource.TrySetException(ex);
 8688                        return;
 8689                    }
 8690
 8691                    self.awaiter13.SourceOnCompleted(Completed13Delegate, self);
 8692                }
 8693                return;
 8694                COMPLETE:
 8695                self.completionSource.TrySetResult(false);
 8696                return;
 8697            }
 8698
 8699            bool TrySetResult()
 8700            {
 8701                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 8702                {
 8703                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 8704                    completionSource.TrySetResult(true);
 8705                    return true;
 8706                }
 8707                else
 8708                {
 8709                    return false;
 8710                }
 8711            }
 8712
 8713            public async UniTask DisposeAsync()
 8714            {
 8715                TaskTracker.RemoveTracking(this);
 8716                if (enumerator1 != null)
 8717                {
 8718                    await enumerator1.DisposeAsync();
 8719                }
 8720                if (enumerator2 != null)
 8721                {
 8722                    await enumerator2.DisposeAsync();
 8723                }
 8724                if (enumerator3 != null)
 8725                {
 8726                    await enumerator3.DisposeAsync();
 8727                }
 8728                if (enumerator4 != null)
 8729                {
 8730                    await enumerator4.DisposeAsync();
 8731                }
 8732                if (enumerator5 != null)
 8733                {
 8734                    await enumerator5.DisposeAsync();
 8735                }
 8736                if (enumerator6 != null)
 8737                {
 8738                    await enumerator6.DisposeAsync();
 8739                }
 8740                if (enumerator7 != null)
 8741                {
 8742                    await enumerator7.DisposeAsync();
 8743                }
 8744                if (enumerator8 != null)
 8745                {
 8746                    await enumerator8.DisposeAsync();
 8747                }
 8748                if (enumerator9 != null)
 8749                {
 8750                    await enumerator9.DisposeAsync();
 8751                }
 8752                if (enumerator10 != null)
 8753                {
 8754                    await enumerator10.DisposeAsync();
 8755                }
 8756                if (enumerator11 != null)
 8757                {
 8758                    await enumerator11.DisposeAsync();
 8759                }
 8760                if (enumerator12 != null)
 8761                {
 8762                    await enumerator12.DisposeAsync();
 8763                }
 8764                if (enumerator13 != null)
 8765                {
 8766                    await enumerator13.DisposeAsync();
 8767                }
 8768            }
 8769        }
 8770    }
 8771
 8772    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> : IUniTaskAsyncEn
 8773    {
 8774        readonly IUniTaskAsyncEnumerable<T1> source1;
 8775        readonly IUniTaskAsyncEnumerable<T2> source2;
 8776        readonly IUniTaskAsyncEnumerable<T3> source3;
 8777        readonly IUniTaskAsyncEnumerable<T4> source4;
 8778        readonly IUniTaskAsyncEnumerable<T5> source5;
 8779        readonly IUniTaskAsyncEnumerable<T6> source6;
 8780        readonly IUniTaskAsyncEnumerable<T7> source7;
 8781        readonly IUniTaskAsyncEnumerable<T8> source8;
 8782        readonly IUniTaskAsyncEnumerable<T9> source9;
 8783        readonly IUniTaskAsyncEnumerable<T10> source10;
 8784        readonly IUniTaskAsyncEnumerable<T11> source11;
 8785        readonly IUniTaskAsyncEnumerable<T12> source12;
 8786        readonly IUniTaskAsyncEnumerable<T13> source13;
 8787        readonly IUniTaskAsyncEnumerable<T14> source14;
 8788
 8789        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector;
 8790
 08791        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 08792        {
 08793            this.source1 = source1;
 08794            this.source2 = source2;
 08795            this.source3 = source3;
 08796            this.source4 = source4;
 08797            this.source5 = source5;
 08798            this.source6 = source6;
 08799            this.source7 = source7;
 08800            this.source8 = source8;
 08801            this.source9 = source9;
 08802            this.source10 = source10;
 08803            this.source11 = source11;
 08804            this.source12 = source12;
 08805            this.source13 = source13;
 08806            this.source14 = source14;
 8807
 08808            this.resultSelector = resultSelector;
 08809        }
 8810
 8811        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 08812        {
 08813            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, s
 08814        }
 8815
 8816        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 8817        {
 08818            static readonly Action<object> Completed1Delegate = Completed1;
 08819            static readonly Action<object> Completed2Delegate = Completed2;
 08820            static readonly Action<object> Completed3Delegate = Completed3;
 08821            static readonly Action<object> Completed4Delegate = Completed4;
 08822            static readonly Action<object> Completed5Delegate = Completed5;
 08823            static readonly Action<object> Completed6Delegate = Completed6;
 08824            static readonly Action<object> Completed7Delegate = Completed7;
 08825            static readonly Action<object> Completed8Delegate = Completed8;
 08826            static readonly Action<object> Completed9Delegate = Completed9;
 08827            static readonly Action<object> Completed10Delegate = Completed10;
 08828            static readonly Action<object> Completed11Delegate = Completed11;
 08829            static readonly Action<object> Completed12Delegate = Completed12;
 08830            static readonly Action<object> Completed13Delegate = Completed13;
 08831            static readonly Action<object> Completed14Delegate = Completed14;
 8832            const int CompleteCount = 14;
 8833
 8834            readonly IUniTaskAsyncEnumerable<T1> source1;
 8835            readonly IUniTaskAsyncEnumerable<T2> source2;
 8836            readonly IUniTaskAsyncEnumerable<T3> source3;
 8837            readonly IUniTaskAsyncEnumerable<T4> source4;
 8838            readonly IUniTaskAsyncEnumerable<T5> source5;
 8839            readonly IUniTaskAsyncEnumerable<T6> source6;
 8840            readonly IUniTaskAsyncEnumerable<T7> source7;
 8841            readonly IUniTaskAsyncEnumerable<T8> source8;
 8842            readonly IUniTaskAsyncEnumerable<T9> source9;
 8843            readonly IUniTaskAsyncEnumerable<T10> source10;
 8844            readonly IUniTaskAsyncEnumerable<T11> source11;
 8845            readonly IUniTaskAsyncEnumerable<T12> source12;
 8846            readonly IUniTaskAsyncEnumerable<T13> source13;
 8847            readonly IUniTaskAsyncEnumerable<T14> source14;
 8848
 8849            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector;
 8850            CancellationToken cancellationToken;
 8851
 8852            IUniTaskAsyncEnumerator<T1> enumerator1;
 8853            UniTask<bool>.Awaiter awaiter1;
 8854            bool hasCurrent1;
 8855            bool running1;
 8856            T1 current1;
 8857
 8858            IUniTaskAsyncEnumerator<T2> enumerator2;
 8859            UniTask<bool>.Awaiter awaiter2;
 8860            bool hasCurrent2;
 8861            bool running2;
 8862            T2 current2;
 8863
 8864            IUniTaskAsyncEnumerator<T3> enumerator3;
 8865            UniTask<bool>.Awaiter awaiter3;
 8866            bool hasCurrent3;
 8867            bool running3;
 8868            T3 current3;
 8869
 8870            IUniTaskAsyncEnumerator<T4> enumerator4;
 8871            UniTask<bool>.Awaiter awaiter4;
 8872            bool hasCurrent4;
 8873            bool running4;
 8874            T4 current4;
 8875
 8876            IUniTaskAsyncEnumerator<T5> enumerator5;
 8877            UniTask<bool>.Awaiter awaiter5;
 8878            bool hasCurrent5;
 8879            bool running5;
 8880            T5 current5;
 8881
 8882            IUniTaskAsyncEnumerator<T6> enumerator6;
 8883            UniTask<bool>.Awaiter awaiter6;
 8884            bool hasCurrent6;
 8885            bool running6;
 8886            T6 current6;
 8887
 8888            IUniTaskAsyncEnumerator<T7> enumerator7;
 8889            UniTask<bool>.Awaiter awaiter7;
 8890            bool hasCurrent7;
 8891            bool running7;
 8892            T7 current7;
 8893
 8894            IUniTaskAsyncEnumerator<T8> enumerator8;
 8895            UniTask<bool>.Awaiter awaiter8;
 8896            bool hasCurrent8;
 8897            bool running8;
 8898            T8 current8;
 8899
 8900            IUniTaskAsyncEnumerator<T9> enumerator9;
 8901            UniTask<bool>.Awaiter awaiter9;
 8902            bool hasCurrent9;
 8903            bool running9;
 8904            T9 current9;
 8905
 8906            IUniTaskAsyncEnumerator<T10> enumerator10;
 8907            UniTask<bool>.Awaiter awaiter10;
 8908            bool hasCurrent10;
 8909            bool running10;
 8910            T10 current10;
 8911
 8912            IUniTaskAsyncEnumerator<T11> enumerator11;
 8913            UniTask<bool>.Awaiter awaiter11;
 8914            bool hasCurrent11;
 8915            bool running11;
 8916            T11 current11;
 8917
 8918            IUniTaskAsyncEnumerator<T12> enumerator12;
 8919            UniTask<bool>.Awaiter awaiter12;
 8920            bool hasCurrent12;
 8921            bool running12;
 8922            T12 current12;
 8923
 8924            IUniTaskAsyncEnumerator<T13> enumerator13;
 8925            UniTask<bool>.Awaiter awaiter13;
 8926            bool hasCurrent13;
 8927            bool running13;
 8928            T13 current13;
 8929
 8930            IUniTaskAsyncEnumerator<T14> enumerator14;
 8931            UniTask<bool>.Awaiter awaiter14;
 8932            bool hasCurrent14;
 8933            bool running14;
 8934            T14 current14;
 8935
 8936            int completedCount;
 8937            bool syncRunning;
 8938            TResult result;
 8939
 08940            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 08941            {
 08942                this.source1 = source1;
 08943                this.source2 = source2;
 08944                this.source3 = source3;
 08945                this.source4 = source4;
 08946                this.source5 = source5;
 08947                this.source6 = source6;
 08948                this.source7 = source7;
 08949                this.source8 = source8;
 08950                this.source9 = source9;
 08951                this.source10 = source10;
 08952                this.source11 = source11;
 08953                this.source12 = source12;
 08954                this.source13 = source13;
 08955                this.source14 = source14;
 8956
 08957                this.resultSelector = resultSelector;
 08958                this.cancellationToken = cancellationToken;
 08959                TaskTracker.TrackActiveTask(this, 3);
 08960            }
 8961
 08962            public TResult Current => result;
 8963
 8964            public UniTask<bool> MoveNextAsync()
 08965            {
 08966                cancellationToken.ThrowIfCancellationRequested();
 08967                if (completedCount == CompleteCount) return CompletedTasks.False;
 8968
 08969                if (enumerator1 == null)
 08970                {
 08971                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 08972                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 08973                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 08974                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 08975                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 08976                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 08977                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 08978                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 08979                    enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
 08980                    enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
 08981                    enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
 08982                    enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
 08983                    enumerator13 = source13.GetAsyncEnumerator(cancellationToken);
 08984                    enumerator14 = source14.GetAsyncEnumerator(cancellationToken);
 08985                }
 8986
 08987                completionSource.Reset();
 8988
 08989                AGAIN:
 08990                syncRunning = true;
 08991                if (!running1)
 08992                {
 08993                    running1 = true;
 08994                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 08995                    if (awaiter1.IsCompleted)
 08996                    {
 08997                        Completed1(this);
 08998                    }
 8999                    else
 09000                    {
 09001                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 09002                    }
 09003                }
 09004                if (!running2)
 09005                {
 09006                    running2 = true;
 09007                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 09008                    if (awaiter2.IsCompleted)
 09009                    {
 09010                        Completed2(this);
 09011                    }
 9012                    else
 09013                    {
 09014                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 09015                    }
 09016                }
 09017                if (!running3)
 09018                {
 09019                    running3 = true;
 09020                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 09021                    if (awaiter3.IsCompleted)
 09022                    {
 09023                        Completed3(this);
 09024                    }
 9025                    else
 09026                    {
 09027                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 09028                    }
 09029                }
 09030                if (!running4)
 09031                {
 09032                    running4 = true;
 09033                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 09034                    if (awaiter4.IsCompleted)
 09035                    {
 09036                        Completed4(this);
 09037                    }
 9038                    else
 09039                    {
 09040                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 09041                    }
 09042                }
 09043                if (!running5)
 09044                {
 09045                    running5 = true;
 09046                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 09047                    if (awaiter5.IsCompleted)
 09048                    {
 09049                        Completed5(this);
 09050                    }
 9051                    else
 09052                    {
 09053                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 09054                    }
 09055                }
 09056                if (!running6)
 09057                {
 09058                    running6 = true;
 09059                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 09060                    if (awaiter6.IsCompleted)
 09061                    {
 09062                        Completed6(this);
 09063                    }
 9064                    else
 09065                    {
 09066                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 09067                    }
 09068                }
 09069                if (!running7)
 09070                {
 09071                    running7 = true;
 09072                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 09073                    if (awaiter7.IsCompleted)
 09074                    {
 09075                        Completed7(this);
 09076                    }
 9077                    else
 09078                    {
 09079                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 09080                    }
 09081                }
 09082                if (!running8)
 09083                {
 09084                    running8 = true;
 09085                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 09086                    if (awaiter8.IsCompleted)
 09087                    {
 09088                        Completed8(this);
 09089                    }
 9090                    else
 09091                    {
 09092                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 09093                    }
 09094                }
 09095                if (!running9)
 09096                {
 09097                    running9 = true;
 09098                    awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
 09099                    if (awaiter9.IsCompleted)
 09100                    {
 09101                        Completed9(this);
 09102                    }
 9103                    else
 09104                    {
 09105                        awaiter9.SourceOnCompleted(Completed9Delegate, this);
 09106                    }
 09107                }
 09108                if (!running10)
 09109                {
 09110                    running10 = true;
 09111                    awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
 09112                    if (awaiter10.IsCompleted)
 09113                    {
 09114                        Completed10(this);
 09115                    }
 9116                    else
 09117                    {
 09118                        awaiter10.SourceOnCompleted(Completed10Delegate, this);
 09119                    }
 09120                }
 09121                if (!running11)
 09122                {
 09123                    running11 = true;
 09124                    awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
 09125                    if (awaiter11.IsCompleted)
 09126                    {
 09127                        Completed11(this);
 09128                    }
 9129                    else
 09130                    {
 09131                        awaiter11.SourceOnCompleted(Completed11Delegate, this);
 09132                    }
 09133                }
 09134                if (!running12)
 09135                {
 09136                    running12 = true;
 09137                    awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
 09138                    if (awaiter12.IsCompleted)
 09139                    {
 09140                        Completed12(this);
 09141                    }
 9142                    else
 09143                    {
 09144                        awaiter12.SourceOnCompleted(Completed12Delegate, this);
 09145                    }
 09146                }
 09147                if (!running13)
 09148                {
 09149                    running13 = true;
 09150                    awaiter13 = enumerator13.MoveNextAsync().GetAwaiter();
 09151                    if (awaiter13.IsCompleted)
 09152                    {
 09153                        Completed13(this);
 09154                    }
 9155                    else
 09156                    {
 09157                        awaiter13.SourceOnCompleted(Completed13Delegate, this);
 09158                    }
 09159                }
 09160                if (!running14)
 09161                {
 09162                    running14 = true;
 09163                    awaiter14 = enumerator14.MoveNextAsync().GetAwaiter();
 09164                    if (awaiter14.IsCompleted)
 09165                    {
 09166                        Completed14(this);
 09167                    }
 9168                    else
 09169                    {
 09170                        awaiter14.SourceOnCompleted(Completed14Delegate, this);
 09171                    }
 09172                }
 9173
 09174                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 09175                {
 09176                    goto AGAIN;
 9177                }
 09178                syncRunning = false;
 9179
 09180                return new UniTask<bool>(this, completionSource.Version);
 09181            }
 9182
 9183            static void Completed1(object state)
 09184            {
 09185                var self = (_CombineLatest)state;
 09186                self.running1 = false;
 9187
 9188                try
 09189                {
 09190                    if (self.awaiter1.GetResult())
 09191                    {
 09192                        self.hasCurrent1 = true;
 09193                        self.current1 = self.enumerator1.Current;
 09194                        goto SUCCESS;
 9195                    }
 9196                    else
 09197                    {
 09198                        self.running1 = true; // as complete, no more call MoveNextAsync.
 09199                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09200                        {
 09201                            goto COMPLETE;
 9202                        }
 09203                        return;
 9204                    }
 9205                }
 09206                catch (Exception ex)
 09207                {
 09208                    self.running1 = true; // as complete, no more call MoveNextAsync.
 09209                    self.completedCount = CompleteCount;
 09210                    self.completionSource.TrySetException(ex);
 09211                    return;
 9212                }
 9213
 09214                SUCCESS:
 09215                if (!self.TrySetResult())
 09216                {
 09217                    if (self.syncRunning) return;
 09218                    self.running1 = true; // as complete, no more call MoveNextAsync.
 9219                    try
 09220                    {
 09221                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 09222                    }
 09223                    catch (Exception ex)
 09224                    {
 09225                        self.completedCount = CompleteCount;
 09226                        self.completionSource.TrySetException(ex);
 09227                        return;
 9228                    }
 9229
 09230                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 09231                }
 09232                return;
 09233                COMPLETE:
 09234                self.completionSource.TrySetResult(false);
 09235                return;
 09236            }
 9237
 9238            static void Completed2(object state)
 09239            {
 09240                var self = (_CombineLatest)state;
 09241                self.running2 = false;
 9242
 9243                try
 09244                {
 09245                    if (self.awaiter2.GetResult())
 09246                    {
 09247                        self.hasCurrent2 = true;
 09248                        self.current2 = self.enumerator2.Current;
 09249                        goto SUCCESS;
 9250                    }
 9251                    else
 09252                    {
 09253                        self.running2 = true; // as complete, no more call MoveNextAsync.
 09254                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09255                        {
 09256                            goto COMPLETE;
 9257                        }
 09258                        return;
 9259                    }
 9260                }
 09261                catch (Exception ex)
 09262                {
 09263                    self.running2 = true; // as complete, no more call MoveNextAsync.
 09264                    self.completedCount = CompleteCount;
 09265                    self.completionSource.TrySetException(ex);
 09266                    return;
 9267                }
 9268
 09269                SUCCESS:
 09270                if (!self.TrySetResult())
 09271                {
 09272                    if (self.syncRunning) return;
 09273                    self.running2 = true; // as complete, no more call MoveNextAsync.
 9274                    try
 09275                    {
 09276                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 09277                    }
 09278                    catch (Exception ex)
 09279                    {
 09280                        self.completedCount = CompleteCount;
 09281                        self.completionSource.TrySetException(ex);
 09282                        return;
 9283                    }
 9284
 09285                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 09286                }
 09287                return;
 09288                COMPLETE:
 09289                self.completionSource.TrySetResult(false);
 09290                return;
 09291            }
 9292
 9293            static void Completed3(object state)
 09294            {
 09295                var self = (_CombineLatest)state;
 09296                self.running3 = false;
 9297
 9298                try
 09299                {
 09300                    if (self.awaiter3.GetResult())
 09301                    {
 09302                        self.hasCurrent3 = true;
 09303                        self.current3 = self.enumerator3.Current;
 09304                        goto SUCCESS;
 9305                    }
 9306                    else
 09307                    {
 09308                        self.running3 = true; // as complete, no more call MoveNextAsync.
 09309                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09310                        {
 09311                            goto COMPLETE;
 9312                        }
 09313                        return;
 9314                    }
 9315                }
 09316                catch (Exception ex)
 09317                {
 09318                    self.running3 = true; // as complete, no more call MoveNextAsync.
 09319                    self.completedCount = CompleteCount;
 09320                    self.completionSource.TrySetException(ex);
 09321                    return;
 9322                }
 9323
 09324                SUCCESS:
 09325                if (!self.TrySetResult())
 09326                {
 09327                    if (self.syncRunning) return;
 09328                    self.running3 = true; // as complete, no more call MoveNextAsync.
 9329                    try
 09330                    {
 09331                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 09332                    }
 09333                    catch (Exception ex)
 09334                    {
 09335                        self.completedCount = CompleteCount;
 09336                        self.completionSource.TrySetException(ex);
 09337                        return;
 9338                    }
 9339
 09340                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 09341                }
 09342                return;
 09343                COMPLETE:
 09344                self.completionSource.TrySetResult(false);
 09345                return;
 09346            }
 9347
 9348            static void Completed4(object state)
 09349            {
 09350                var self = (_CombineLatest)state;
 09351                self.running4 = false;
 9352
 9353                try
 09354                {
 09355                    if (self.awaiter4.GetResult())
 09356                    {
 09357                        self.hasCurrent4 = true;
 09358                        self.current4 = self.enumerator4.Current;
 09359                        goto SUCCESS;
 9360                    }
 9361                    else
 09362                    {
 09363                        self.running4 = true; // as complete, no more call MoveNextAsync.
 09364                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09365                        {
 09366                            goto COMPLETE;
 9367                        }
 09368                        return;
 9369                    }
 9370                }
 09371                catch (Exception ex)
 09372                {
 09373                    self.running4 = true; // as complete, no more call MoveNextAsync.
 09374                    self.completedCount = CompleteCount;
 09375                    self.completionSource.TrySetException(ex);
 09376                    return;
 9377                }
 9378
 09379                SUCCESS:
 09380                if (!self.TrySetResult())
 09381                {
 09382                    if (self.syncRunning) return;
 09383                    self.running4 = true; // as complete, no more call MoveNextAsync.
 9384                    try
 09385                    {
 09386                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 09387                    }
 09388                    catch (Exception ex)
 09389                    {
 09390                        self.completedCount = CompleteCount;
 09391                        self.completionSource.TrySetException(ex);
 09392                        return;
 9393                    }
 9394
 09395                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 09396                }
 09397                return;
 09398                COMPLETE:
 09399                self.completionSource.TrySetResult(false);
 09400                return;
 09401            }
 9402
 9403            static void Completed5(object state)
 09404            {
 09405                var self = (_CombineLatest)state;
 09406                self.running5 = false;
 9407
 9408                try
 09409                {
 09410                    if (self.awaiter5.GetResult())
 09411                    {
 09412                        self.hasCurrent5 = true;
 09413                        self.current5 = self.enumerator5.Current;
 09414                        goto SUCCESS;
 9415                    }
 9416                    else
 09417                    {
 09418                        self.running5 = true; // as complete, no more call MoveNextAsync.
 09419                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09420                        {
 09421                            goto COMPLETE;
 9422                        }
 09423                        return;
 9424                    }
 9425                }
 09426                catch (Exception ex)
 09427                {
 09428                    self.running5 = true; // as complete, no more call MoveNextAsync.
 09429                    self.completedCount = CompleteCount;
 09430                    self.completionSource.TrySetException(ex);
 09431                    return;
 9432                }
 9433
 09434                SUCCESS:
 09435                if (!self.TrySetResult())
 09436                {
 09437                    if (self.syncRunning) return;
 09438                    self.running5 = true; // as complete, no more call MoveNextAsync.
 9439                    try
 09440                    {
 09441                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 09442                    }
 09443                    catch (Exception ex)
 09444                    {
 09445                        self.completedCount = CompleteCount;
 09446                        self.completionSource.TrySetException(ex);
 09447                        return;
 9448                    }
 9449
 09450                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 09451                }
 09452                return;
 09453                COMPLETE:
 09454                self.completionSource.TrySetResult(false);
 09455                return;
 09456            }
 9457
 9458            static void Completed6(object state)
 09459            {
 09460                var self = (_CombineLatest)state;
 09461                self.running6 = false;
 9462
 9463                try
 09464                {
 09465                    if (self.awaiter6.GetResult())
 09466                    {
 09467                        self.hasCurrent6 = true;
 09468                        self.current6 = self.enumerator6.Current;
 09469                        goto SUCCESS;
 9470                    }
 9471                    else
 09472                    {
 09473                        self.running6 = true; // as complete, no more call MoveNextAsync.
 09474                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09475                        {
 09476                            goto COMPLETE;
 9477                        }
 09478                        return;
 9479                    }
 9480                }
 09481                catch (Exception ex)
 09482                {
 09483                    self.running6 = true; // as complete, no more call MoveNextAsync.
 09484                    self.completedCount = CompleteCount;
 09485                    self.completionSource.TrySetException(ex);
 09486                    return;
 9487                }
 9488
 09489                SUCCESS:
 09490                if (!self.TrySetResult())
 09491                {
 09492                    if (self.syncRunning) return;
 09493                    self.running6 = true; // as complete, no more call MoveNextAsync.
 9494                    try
 09495                    {
 09496                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 09497                    }
 09498                    catch (Exception ex)
 09499                    {
 09500                        self.completedCount = CompleteCount;
 09501                        self.completionSource.TrySetException(ex);
 09502                        return;
 9503                    }
 9504
 09505                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 09506                }
 09507                return;
 09508                COMPLETE:
 09509                self.completionSource.TrySetResult(false);
 09510                return;
 09511            }
 9512
 9513            static void Completed7(object state)
 09514            {
 09515                var self = (_CombineLatest)state;
 09516                self.running7 = false;
 9517
 9518                try
 09519                {
 09520                    if (self.awaiter7.GetResult())
 09521                    {
 09522                        self.hasCurrent7 = true;
 09523                        self.current7 = self.enumerator7.Current;
 09524                        goto SUCCESS;
 9525                    }
 9526                    else
 09527                    {
 09528                        self.running7 = true; // as complete, no more call MoveNextAsync.
 09529                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09530                        {
 09531                            goto COMPLETE;
 9532                        }
 09533                        return;
 9534                    }
 9535                }
 09536                catch (Exception ex)
 09537                {
 09538                    self.running7 = true; // as complete, no more call MoveNextAsync.
 09539                    self.completedCount = CompleteCount;
 09540                    self.completionSource.TrySetException(ex);
 09541                    return;
 9542                }
 9543
 09544                SUCCESS:
 09545                if (!self.TrySetResult())
 09546                {
 09547                    if (self.syncRunning) return;
 09548                    self.running7 = true; // as complete, no more call MoveNextAsync.
 9549                    try
 09550                    {
 09551                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 09552                    }
 09553                    catch (Exception ex)
 09554                    {
 09555                        self.completedCount = CompleteCount;
 09556                        self.completionSource.TrySetException(ex);
 09557                        return;
 9558                    }
 9559
 09560                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 09561                }
 09562                return;
 09563                COMPLETE:
 09564                self.completionSource.TrySetResult(false);
 09565                return;
 09566            }
 9567
 9568            static void Completed8(object state)
 09569            {
 09570                var self = (_CombineLatest)state;
 09571                self.running8 = false;
 9572
 9573                try
 09574                {
 09575                    if (self.awaiter8.GetResult())
 09576                    {
 09577                        self.hasCurrent8 = true;
 09578                        self.current8 = self.enumerator8.Current;
 09579                        goto SUCCESS;
 9580                    }
 9581                    else
 09582                    {
 09583                        self.running8 = true; // as complete, no more call MoveNextAsync.
 09584                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09585                        {
 09586                            goto COMPLETE;
 9587                        }
 09588                        return;
 9589                    }
 9590                }
 09591                catch (Exception ex)
 09592                {
 09593                    self.running8 = true; // as complete, no more call MoveNextAsync.
 09594                    self.completedCount = CompleteCount;
 09595                    self.completionSource.TrySetException(ex);
 09596                    return;
 9597                }
 9598
 09599                SUCCESS:
 09600                if (!self.TrySetResult())
 09601                {
 09602                    if (self.syncRunning) return;
 09603                    self.running8 = true; // as complete, no more call MoveNextAsync.
 9604                    try
 09605                    {
 09606                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 09607                    }
 09608                    catch (Exception ex)
 09609                    {
 09610                        self.completedCount = CompleteCount;
 09611                        self.completionSource.TrySetException(ex);
 09612                        return;
 9613                    }
 9614
 09615                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 09616                }
 09617                return;
 09618                COMPLETE:
 09619                self.completionSource.TrySetResult(false);
 09620                return;
 09621            }
 9622
 9623            static void Completed9(object state)
 09624            {
 09625                var self = (_CombineLatest)state;
 09626                self.running9 = false;
 9627
 9628                try
 09629                {
 09630                    if (self.awaiter9.GetResult())
 09631                    {
 09632                        self.hasCurrent9 = true;
 09633                        self.current9 = self.enumerator9.Current;
 09634                        goto SUCCESS;
 9635                    }
 9636                    else
 09637                    {
 09638                        self.running9 = true; // as complete, no more call MoveNextAsync.
 09639                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09640                        {
 09641                            goto COMPLETE;
 9642                        }
 09643                        return;
 9644                    }
 9645                }
 09646                catch (Exception ex)
 09647                {
 09648                    self.running9 = true; // as complete, no more call MoveNextAsync.
 09649                    self.completedCount = CompleteCount;
 09650                    self.completionSource.TrySetException(ex);
 09651                    return;
 9652                }
 9653
 09654                SUCCESS:
 09655                if (!self.TrySetResult())
 09656                {
 09657                    if (self.syncRunning) return;
 09658                    self.running9 = true; // as complete, no more call MoveNextAsync.
 9659                    try
 09660                    {
 09661                        self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter();
 09662                    }
 09663                    catch (Exception ex)
 09664                    {
 09665                        self.completedCount = CompleteCount;
 09666                        self.completionSource.TrySetException(ex);
 09667                        return;
 9668                    }
 9669
 09670                    self.awaiter9.SourceOnCompleted(Completed9Delegate, self);
 09671                }
 09672                return;
 09673                COMPLETE:
 09674                self.completionSource.TrySetResult(false);
 09675                return;
 09676            }
 9677
 9678            static void Completed10(object state)
 09679            {
 09680                var self = (_CombineLatest)state;
 09681                self.running10 = false;
 9682
 9683                try
 09684                {
 09685                    if (self.awaiter10.GetResult())
 09686                    {
 09687                        self.hasCurrent10 = true;
 09688                        self.current10 = self.enumerator10.Current;
 09689                        goto SUCCESS;
 9690                    }
 9691                    else
 09692                    {
 09693                        self.running10 = true; // as complete, no more call MoveNextAsync.
 09694                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09695                        {
 09696                            goto COMPLETE;
 9697                        }
 09698                        return;
 9699                    }
 9700                }
 09701                catch (Exception ex)
 09702                {
 09703                    self.running10 = true; // as complete, no more call MoveNextAsync.
 09704                    self.completedCount = CompleteCount;
 09705                    self.completionSource.TrySetException(ex);
 09706                    return;
 9707                }
 9708
 09709                SUCCESS:
 09710                if (!self.TrySetResult())
 09711                {
 09712                    if (self.syncRunning) return;
 09713                    self.running10 = true; // as complete, no more call MoveNextAsync.
 9714                    try
 09715                    {
 09716                        self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter();
 09717                    }
 09718                    catch (Exception ex)
 09719                    {
 09720                        self.completedCount = CompleteCount;
 09721                        self.completionSource.TrySetException(ex);
 09722                        return;
 9723                    }
 9724
 09725                    self.awaiter10.SourceOnCompleted(Completed10Delegate, self);
 09726                }
 09727                return;
 09728                COMPLETE:
 09729                self.completionSource.TrySetResult(false);
 09730                return;
 09731            }
 9732
 9733            static void Completed11(object state)
 09734            {
 09735                var self = (_CombineLatest)state;
 09736                self.running11 = false;
 9737
 9738                try
 09739                {
 09740                    if (self.awaiter11.GetResult())
 09741                    {
 09742                        self.hasCurrent11 = true;
 09743                        self.current11 = self.enumerator11.Current;
 09744                        goto SUCCESS;
 9745                    }
 9746                    else
 09747                    {
 09748                        self.running11 = true; // as complete, no more call MoveNextAsync.
 09749                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09750                        {
 09751                            goto COMPLETE;
 9752                        }
 09753                        return;
 9754                    }
 9755                }
 09756                catch (Exception ex)
 09757                {
 09758                    self.running11 = true; // as complete, no more call MoveNextAsync.
 09759                    self.completedCount = CompleteCount;
 09760                    self.completionSource.TrySetException(ex);
 09761                    return;
 9762                }
 9763
 09764                SUCCESS:
 09765                if (!self.TrySetResult())
 09766                {
 09767                    if (self.syncRunning) return;
 09768                    self.running11 = true; // as complete, no more call MoveNextAsync.
 9769                    try
 09770                    {
 09771                        self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter();
 09772                    }
 09773                    catch (Exception ex)
 09774                    {
 09775                        self.completedCount = CompleteCount;
 09776                        self.completionSource.TrySetException(ex);
 09777                        return;
 9778                    }
 9779
 09780                    self.awaiter11.SourceOnCompleted(Completed11Delegate, self);
 09781                }
 09782                return;
 09783                COMPLETE:
 09784                self.completionSource.TrySetResult(false);
 09785                return;
 09786            }
 9787
 9788            static void Completed12(object state)
 09789            {
 09790                var self = (_CombineLatest)state;
 09791                self.running12 = false;
 9792
 9793                try
 09794                {
 09795                    if (self.awaiter12.GetResult())
 09796                    {
 09797                        self.hasCurrent12 = true;
 09798                        self.current12 = self.enumerator12.Current;
 09799                        goto SUCCESS;
 9800                    }
 9801                    else
 09802                    {
 09803                        self.running12 = true; // as complete, no more call MoveNextAsync.
 09804                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09805                        {
 09806                            goto COMPLETE;
 9807                        }
 09808                        return;
 9809                    }
 9810                }
 09811                catch (Exception ex)
 09812                {
 09813                    self.running12 = true; // as complete, no more call MoveNextAsync.
 09814                    self.completedCount = CompleteCount;
 09815                    self.completionSource.TrySetException(ex);
 09816                    return;
 9817                }
 9818
 09819                SUCCESS:
 09820                if (!self.TrySetResult())
 09821                {
 09822                    if (self.syncRunning) return;
 09823                    self.running12 = true; // as complete, no more call MoveNextAsync.
 9824                    try
 09825                    {
 09826                        self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter();
 09827                    }
 09828                    catch (Exception ex)
 09829                    {
 09830                        self.completedCount = CompleteCount;
 09831                        self.completionSource.TrySetException(ex);
 09832                        return;
 9833                    }
 9834
 09835                    self.awaiter12.SourceOnCompleted(Completed12Delegate, self);
 09836                }
 09837                return;
 09838                COMPLETE:
 09839                self.completionSource.TrySetResult(false);
 09840                return;
 09841            }
 9842
 9843            static void Completed13(object state)
 09844            {
 09845                var self = (_CombineLatest)state;
 09846                self.running13 = false;
 9847
 9848                try
 09849                {
 09850                    if (self.awaiter13.GetResult())
 09851                    {
 09852                        self.hasCurrent13 = true;
 09853                        self.current13 = self.enumerator13.Current;
 09854                        goto SUCCESS;
 9855                    }
 9856                    else
 09857                    {
 09858                        self.running13 = true; // as complete, no more call MoveNextAsync.
 09859                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09860                        {
 09861                            goto COMPLETE;
 9862                        }
 09863                        return;
 9864                    }
 9865                }
 09866                catch (Exception ex)
 09867                {
 09868                    self.running13 = true; // as complete, no more call MoveNextAsync.
 09869                    self.completedCount = CompleteCount;
 09870                    self.completionSource.TrySetException(ex);
 09871                    return;
 9872                }
 9873
 09874                SUCCESS:
 09875                if (!self.TrySetResult())
 09876                {
 09877                    if (self.syncRunning) return;
 09878                    self.running13 = true; // as complete, no more call MoveNextAsync.
 9879                    try
 09880                    {
 09881                        self.awaiter13 = self.enumerator13.MoveNextAsync().GetAwaiter();
 09882                    }
 09883                    catch (Exception ex)
 09884                    {
 09885                        self.completedCount = CompleteCount;
 09886                        self.completionSource.TrySetException(ex);
 09887                        return;
 9888                    }
 9889
 09890                    self.awaiter13.SourceOnCompleted(Completed13Delegate, self);
 09891                }
 09892                return;
 09893                COMPLETE:
 09894                self.completionSource.TrySetResult(false);
 09895                return;
 09896            }
 9897
 9898            static void Completed14(object state)
 09899            {
 09900                var self = (_CombineLatest)state;
 09901                self.running14 = false;
 9902
 9903                try
 09904                {
 09905                    if (self.awaiter14.GetResult())
 09906                    {
 09907                        self.hasCurrent14 = true;
 09908                        self.current14 = self.enumerator14.Current;
 09909                        goto SUCCESS;
 9910                    }
 9911                    else
 09912                    {
 09913                        self.running14 = true; // as complete, no more call MoveNextAsync.
 09914                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 09915                        {
 09916                            goto COMPLETE;
 9917                        }
 09918                        return;
 9919                    }
 9920                }
 09921                catch (Exception ex)
 09922                {
 09923                    self.running14 = true; // as complete, no more call MoveNextAsync.
 09924                    self.completedCount = CompleteCount;
 09925                    self.completionSource.TrySetException(ex);
 09926                    return;
 9927                }
 9928
 09929                SUCCESS:
 09930                if (!self.TrySetResult())
 09931                {
 09932                    if (self.syncRunning) return;
 09933                    self.running14 = true; // as complete, no more call MoveNextAsync.
 9934                    try
 09935                    {
 09936                        self.awaiter14 = self.enumerator14.MoveNextAsync().GetAwaiter();
 09937                    }
 09938                    catch (Exception ex)
 09939                    {
 09940                        self.completedCount = CompleteCount;
 09941                        self.completionSource.TrySetException(ex);
 09942                        return;
 9943                    }
 9944
 09945                    self.awaiter14.SourceOnCompleted(Completed14Delegate, self);
 09946                }
 09947                return;
 09948                COMPLETE:
 09949                self.completionSource.TrySetResult(false);
 09950                return;
 09951            }
 9952
 9953            bool TrySetResult()
 09954            {
 09955                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 09956                {
 09957                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 09958                    completionSource.TrySetResult(true);
 09959                    return true;
 9960                }
 9961                else
 09962                {
 09963                    return false;
 9964                }
 09965            }
 9966
 9967            public async UniTask DisposeAsync()
 09968            {
 09969                TaskTracker.RemoveTracking(this);
 09970                if (enumerator1 != null)
 09971                {
 09972                    await enumerator1.DisposeAsync();
 09973                }
 09974                if (enumerator2 != null)
 09975                {
 09976                    await enumerator2.DisposeAsync();
 09977                }
 09978                if (enumerator3 != null)
 09979                {
 09980                    await enumerator3.DisposeAsync();
 09981                }
 09982                if (enumerator4 != null)
 09983                {
 09984                    await enumerator4.DisposeAsync();
 09985                }
 09986                if (enumerator5 != null)
 09987                {
 09988                    await enumerator5.DisposeAsync();
 09989                }
 09990                if (enumerator6 != null)
 09991                {
 09992                    await enumerator6.DisposeAsync();
 09993                }
 09994                if (enumerator7 != null)
 09995                {
 09996                    await enumerator7.DisposeAsync();
 09997                }
 09998                if (enumerator8 != null)
 09999                {
 010000                    await enumerator8.DisposeAsync();
 010001                }
 010002                if (enumerator9 != null)
 010003                {
 010004                    await enumerator9.DisposeAsync();
 010005                }
 010006                if (enumerator10 != null)
 010007                {
 010008                    await enumerator10.DisposeAsync();
 010009                }
 010010                if (enumerator11 != null)
 010011                {
 010012                    await enumerator11.DisposeAsync();
 010013                }
 010014                if (enumerator12 != null)
 010015                {
 010016                    await enumerator12.DisposeAsync();
 010017                }
 010018                if (enumerator13 != null)
 010019                {
 010020                    await enumerator13.DisposeAsync();
 010021                }
 010022                if (enumerator14 != null)
 010023                {
 010024                    await enumerator14.DisposeAsync();
 010025                }
 010026            }
 10027        }
 10028    }
 10029
 10030    internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> : IUniTaskAs
 10031    {
 10032        readonly IUniTaskAsyncEnumerable<T1> source1;
 10033        readonly IUniTaskAsyncEnumerable<T2> source2;
 10034        readonly IUniTaskAsyncEnumerable<T3> source3;
 10035        readonly IUniTaskAsyncEnumerable<T4> source4;
 10036        readonly IUniTaskAsyncEnumerable<T5> source5;
 10037        readonly IUniTaskAsyncEnumerable<T6> source6;
 10038        readonly IUniTaskAsyncEnumerable<T7> source7;
 10039        readonly IUniTaskAsyncEnumerable<T8> source8;
 10040        readonly IUniTaskAsyncEnumerable<T9> source9;
 10041        readonly IUniTaskAsyncEnumerable<T10> source10;
 10042        readonly IUniTaskAsyncEnumerable<T11> source11;
 10043        readonly IUniTaskAsyncEnumerable<T12> source12;
 10044        readonly IUniTaskAsyncEnumerable<T13> source13;
 10045        readonly IUniTaskAsyncEnumerable<T14> source14;
 10046        readonly IUniTaskAsyncEnumerable<T15> source15;
 10047
 10048        readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector;
 10049
 10050        public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnum
 10051        {
 10052            this.source1 = source1;
 10053            this.source2 = source2;
 10054            this.source3 = source3;
 10055            this.source4 = source4;
 10056            this.source5 = source5;
 10057            this.source6 = source6;
 10058            this.source7 = source7;
 10059            this.source8 = source8;
 10060            this.source9 = source9;
 10061            this.source10 = source10;
 10062            this.source11 = source11;
 10063            this.source12 = source12;
 10064            this.source13 = source13;
 10065            this.source14 = source14;
 10066            this.source15 = source15;
 10067
 10068            this.resultSelector = resultSelector;
 10069        }
 10070
 10071        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
 10072        {
 10073            return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, s
 10074        }
 10075
 10076        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
 10077        {
 10078            static readonly Action<object> Completed1Delegate = Completed1;
 10079            static readonly Action<object> Completed2Delegate = Completed2;
 10080            static readonly Action<object> Completed3Delegate = Completed3;
 10081            static readonly Action<object> Completed4Delegate = Completed4;
 10082            static readonly Action<object> Completed5Delegate = Completed5;
 10083            static readonly Action<object> Completed6Delegate = Completed6;
 10084            static readonly Action<object> Completed7Delegate = Completed7;
 10085            static readonly Action<object> Completed8Delegate = Completed8;
 10086            static readonly Action<object> Completed9Delegate = Completed9;
 10087            static readonly Action<object> Completed10Delegate = Completed10;
 10088            static readonly Action<object> Completed11Delegate = Completed11;
 10089            static readonly Action<object> Completed12Delegate = Completed12;
 10090            static readonly Action<object> Completed13Delegate = Completed13;
 10091            static readonly Action<object> Completed14Delegate = Completed14;
 10092            static readonly Action<object> Completed15Delegate = Completed15;
 10093            const int CompleteCount = 15;
 10094
 10095            readonly IUniTaskAsyncEnumerable<T1> source1;
 10096            readonly IUniTaskAsyncEnumerable<T2> source2;
 10097            readonly IUniTaskAsyncEnumerable<T3> source3;
 10098            readonly IUniTaskAsyncEnumerable<T4> source4;
 10099            readonly IUniTaskAsyncEnumerable<T5> source5;
 10100            readonly IUniTaskAsyncEnumerable<T6> source6;
 10101            readonly IUniTaskAsyncEnumerable<T7> source7;
 10102            readonly IUniTaskAsyncEnumerable<T8> source8;
 10103            readonly IUniTaskAsyncEnumerable<T9> source9;
 10104            readonly IUniTaskAsyncEnumerable<T10> source10;
 10105            readonly IUniTaskAsyncEnumerable<T11> source11;
 10106            readonly IUniTaskAsyncEnumerable<T12> source12;
 10107            readonly IUniTaskAsyncEnumerable<T13> source13;
 10108            readonly IUniTaskAsyncEnumerable<T14> source14;
 10109            readonly IUniTaskAsyncEnumerable<T15> source15;
 10110
 10111            readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector;
 10112            CancellationToken cancellationToken;
 10113
 10114            IUniTaskAsyncEnumerator<T1> enumerator1;
 10115            UniTask<bool>.Awaiter awaiter1;
 10116            bool hasCurrent1;
 10117            bool running1;
 10118            T1 current1;
 10119
 10120            IUniTaskAsyncEnumerator<T2> enumerator2;
 10121            UniTask<bool>.Awaiter awaiter2;
 10122            bool hasCurrent2;
 10123            bool running2;
 10124            T2 current2;
 10125
 10126            IUniTaskAsyncEnumerator<T3> enumerator3;
 10127            UniTask<bool>.Awaiter awaiter3;
 10128            bool hasCurrent3;
 10129            bool running3;
 10130            T3 current3;
 10131
 10132            IUniTaskAsyncEnumerator<T4> enumerator4;
 10133            UniTask<bool>.Awaiter awaiter4;
 10134            bool hasCurrent4;
 10135            bool running4;
 10136            T4 current4;
 10137
 10138            IUniTaskAsyncEnumerator<T5> enumerator5;
 10139            UniTask<bool>.Awaiter awaiter5;
 10140            bool hasCurrent5;
 10141            bool running5;
 10142            T5 current5;
 10143
 10144            IUniTaskAsyncEnumerator<T6> enumerator6;
 10145            UniTask<bool>.Awaiter awaiter6;
 10146            bool hasCurrent6;
 10147            bool running6;
 10148            T6 current6;
 10149
 10150            IUniTaskAsyncEnumerator<T7> enumerator7;
 10151            UniTask<bool>.Awaiter awaiter7;
 10152            bool hasCurrent7;
 10153            bool running7;
 10154            T7 current7;
 10155
 10156            IUniTaskAsyncEnumerator<T8> enumerator8;
 10157            UniTask<bool>.Awaiter awaiter8;
 10158            bool hasCurrent8;
 10159            bool running8;
 10160            T8 current8;
 10161
 10162            IUniTaskAsyncEnumerator<T9> enumerator9;
 10163            UniTask<bool>.Awaiter awaiter9;
 10164            bool hasCurrent9;
 10165            bool running9;
 10166            T9 current9;
 10167
 10168            IUniTaskAsyncEnumerator<T10> enumerator10;
 10169            UniTask<bool>.Awaiter awaiter10;
 10170            bool hasCurrent10;
 10171            bool running10;
 10172            T10 current10;
 10173
 10174            IUniTaskAsyncEnumerator<T11> enumerator11;
 10175            UniTask<bool>.Awaiter awaiter11;
 10176            bool hasCurrent11;
 10177            bool running11;
 10178            T11 current11;
 10179
 10180            IUniTaskAsyncEnumerator<T12> enumerator12;
 10181            UniTask<bool>.Awaiter awaiter12;
 10182            bool hasCurrent12;
 10183            bool running12;
 10184            T12 current12;
 10185
 10186            IUniTaskAsyncEnumerator<T13> enumerator13;
 10187            UniTask<bool>.Awaiter awaiter13;
 10188            bool hasCurrent13;
 10189            bool running13;
 10190            T13 current13;
 10191
 10192            IUniTaskAsyncEnumerator<T14> enumerator14;
 10193            UniTask<bool>.Awaiter awaiter14;
 10194            bool hasCurrent14;
 10195            bool running14;
 10196            T14 current14;
 10197
 10198            IUniTaskAsyncEnumerator<T15> enumerator15;
 10199            UniTask<bool>.Awaiter awaiter15;
 10200            bool hasCurrent15;
 10201            bool running15;
 10202            T15 current15;
 10203
 10204            int completedCount;
 10205            bool syncRunning;
 10206            TResult result;
 10207
 10208            public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyn
 10209            {
 10210                this.source1 = source1;
 10211                this.source2 = source2;
 10212                this.source3 = source3;
 10213                this.source4 = source4;
 10214                this.source5 = source5;
 10215                this.source6 = source6;
 10216                this.source7 = source7;
 10217                this.source8 = source8;
 10218                this.source9 = source9;
 10219                this.source10 = source10;
 10220                this.source11 = source11;
 10221                this.source12 = source12;
 10222                this.source13 = source13;
 10223                this.source14 = source14;
 10224                this.source15 = source15;
 10225
 10226                this.resultSelector = resultSelector;
 10227                this.cancellationToken = cancellationToken;
 10228                TaskTracker.TrackActiveTask(this, 3);
 10229            }
 10230
 10231            public TResult Current => result;
 10232
 10233            public UniTask<bool> MoveNextAsync()
 10234            {
 10235                cancellationToken.ThrowIfCancellationRequested();
 10236                if (completedCount == CompleteCount) return CompletedTasks.False;
 10237
 10238                if (enumerator1 == null)
 10239                {
 10240                    enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
 10241                    enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
 10242                    enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
 10243                    enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
 10244                    enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
 10245                    enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
 10246                    enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
 10247                    enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
 10248                    enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
 10249                    enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
 10250                    enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
 10251                    enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
 10252                    enumerator13 = source13.GetAsyncEnumerator(cancellationToken);
 10253                    enumerator14 = source14.GetAsyncEnumerator(cancellationToken);
 10254                    enumerator15 = source15.GetAsyncEnumerator(cancellationToken);
 10255                }
 10256
 10257                completionSource.Reset();
 10258
 10259                AGAIN:
 10260                syncRunning = true;
 10261                if (!running1)
 10262                {
 10263                    running1 = true;
 10264                    awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
 10265                    if (awaiter1.IsCompleted)
 10266                    {
 10267                        Completed1(this);
 10268                    }
 10269                    else
 10270                    {
 10271                        awaiter1.SourceOnCompleted(Completed1Delegate, this);
 10272                    }
 10273                }
 10274                if (!running2)
 10275                {
 10276                    running2 = true;
 10277                    awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
 10278                    if (awaiter2.IsCompleted)
 10279                    {
 10280                        Completed2(this);
 10281                    }
 10282                    else
 10283                    {
 10284                        awaiter2.SourceOnCompleted(Completed2Delegate, this);
 10285                    }
 10286                }
 10287                if (!running3)
 10288                {
 10289                    running3 = true;
 10290                    awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
 10291                    if (awaiter3.IsCompleted)
 10292                    {
 10293                        Completed3(this);
 10294                    }
 10295                    else
 10296                    {
 10297                        awaiter3.SourceOnCompleted(Completed3Delegate, this);
 10298                    }
 10299                }
 10300                if (!running4)
 10301                {
 10302                    running4 = true;
 10303                    awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
 10304                    if (awaiter4.IsCompleted)
 10305                    {
 10306                        Completed4(this);
 10307                    }
 10308                    else
 10309                    {
 10310                        awaiter4.SourceOnCompleted(Completed4Delegate, this);
 10311                    }
 10312                }
 10313                if (!running5)
 10314                {
 10315                    running5 = true;
 10316                    awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
 10317                    if (awaiter5.IsCompleted)
 10318                    {
 10319                        Completed5(this);
 10320                    }
 10321                    else
 10322                    {
 10323                        awaiter5.SourceOnCompleted(Completed5Delegate, this);
 10324                    }
 10325                }
 10326                if (!running6)
 10327                {
 10328                    running6 = true;
 10329                    awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
 10330                    if (awaiter6.IsCompleted)
 10331                    {
 10332                        Completed6(this);
 10333                    }
 10334                    else
 10335                    {
 10336                        awaiter6.SourceOnCompleted(Completed6Delegate, this);
 10337                    }
 10338                }
 10339                if (!running7)
 10340                {
 10341                    running7 = true;
 10342                    awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
 10343                    if (awaiter7.IsCompleted)
 10344                    {
 10345                        Completed7(this);
 10346                    }
 10347                    else
 10348                    {
 10349                        awaiter7.SourceOnCompleted(Completed7Delegate, this);
 10350                    }
 10351                }
 10352                if (!running8)
 10353                {
 10354                    running8 = true;
 10355                    awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
 10356                    if (awaiter8.IsCompleted)
 10357                    {
 10358                        Completed8(this);
 10359                    }
 10360                    else
 10361                    {
 10362                        awaiter8.SourceOnCompleted(Completed8Delegate, this);
 10363                    }
 10364                }
 10365                if (!running9)
 10366                {
 10367                    running9 = true;
 10368                    awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
 10369                    if (awaiter9.IsCompleted)
 10370                    {
 10371                        Completed9(this);
 10372                    }
 10373                    else
 10374                    {
 10375                        awaiter9.SourceOnCompleted(Completed9Delegate, this);
 10376                    }
 10377                }
 10378                if (!running10)
 10379                {
 10380                    running10 = true;
 10381                    awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
 10382                    if (awaiter10.IsCompleted)
 10383                    {
 10384                        Completed10(this);
 10385                    }
 10386                    else
 10387                    {
 10388                        awaiter10.SourceOnCompleted(Completed10Delegate, this);
 10389                    }
 10390                }
 10391                if (!running11)
 10392                {
 10393                    running11 = true;
 10394                    awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
 10395                    if (awaiter11.IsCompleted)
 10396                    {
 10397                        Completed11(this);
 10398                    }
 10399                    else
 10400                    {
 10401                        awaiter11.SourceOnCompleted(Completed11Delegate, this);
 10402                    }
 10403                }
 10404                if (!running12)
 10405                {
 10406                    running12 = true;
 10407                    awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
 10408                    if (awaiter12.IsCompleted)
 10409                    {
 10410                        Completed12(this);
 10411                    }
 10412                    else
 10413                    {
 10414                        awaiter12.SourceOnCompleted(Completed12Delegate, this);
 10415                    }
 10416                }
 10417                if (!running13)
 10418                {
 10419                    running13 = true;
 10420                    awaiter13 = enumerator13.MoveNextAsync().GetAwaiter();
 10421                    if (awaiter13.IsCompleted)
 10422                    {
 10423                        Completed13(this);
 10424                    }
 10425                    else
 10426                    {
 10427                        awaiter13.SourceOnCompleted(Completed13Delegate, this);
 10428                    }
 10429                }
 10430                if (!running14)
 10431                {
 10432                    running14 = true;
 10433                    awaiter14 = enumerator14.MoveNextAsync().GetAwaiter();
 10434                    if (awaiter14.IsCompleted)
 10435                    {
 10436                        Completed14(this);
 10437                    }
 10438                    else
 10439                    {
 10440                        awaiter14.SourceOnCompleted(Completed14Delegate, this);
 10441                    }
 10442                }
 10443                if (!running15)
 10444                {
 10445                    running15 = true;
 10446                    awaiter15 = enumerator15.MoveNextAsync().GetAwaiter();
 10447                    if (awaiter15.IsCompleted)
 10448                    {
 10449                        Completed15(this);
 10450                    }
 10451                    else
 10452                    {
 10453                        awaiter15.SourceOnCompleted(Completed15Delegate, this);
 10454                    }
 10455                }
 10456
 10457                if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8
 10458                {
 10459                    goto AGAIN;
 10460                }
 10461                syncRunning = false;
 10462
 10463                return new UniTask<bool>(this, completionSource.Version);
 10464            }
 10465
 10466            static void Completed1(object state)
 10467            {
 10468                var self = (_CombineLatest)state;
 10469                self.running1 = false;
 10470
 10471                try
 10472                {
 10473                    if (self.awaiter1.GetResult())
 10474                    {
 10475                        self.hasCurrent1 = true;
 10476                        self.current1 = self.enumerator1.Current;
 10477                        goto SUCCESS;
 10478                    }
 10479                    else
 10480                    {
 10481                        self.running1 = true; // as complete, no more call MoveNextAsync.
 10482                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10483                        {
 10484                            goto COMPLETE;
 10485                        }
 10486                        return;
 10487                    }
 10488                }
 10489                catch (Exception ex)
 10490                {
 10491                    self.running1 = true; // as complete, no more call MoveNextAsync.
 10492                    self.completedCount = CompleteCount;
 10493                    self.completionSource.TrySetException(ex);
 10494                    return;
 10495                }
 10496
 10497                SUCCESS:
 10498                if (!self.TrySetResult())
 10499                {
 10500                    if (self.syncRunning) return;
 10501                    self.running1 = true; // as complete, no more call MoveNextAsync.
 10502                    try
 10503                    {
 10504                        self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter();
 10505                    }
 10506                    catch (Exception ex)
 10507                    {
 10508                        self.completedCount = CompleteCount;
 10509                        self.completionSource.TrySetException(ex);
 10510                        return;
 10511                    }
 10512
 10513                    self.awaiter1.SourceOnCompleted(Completed1Delegate, self);
 10514                }
 10515                return;
 10516                COMPLETE:
 10517                self.completionSource.TrySetResult(false);
 10518                return;
 10519            }
 10520
 10521            static void Completed2(object state)
 10522            {
 10523                var self = (_CombineLatest)state;
 10524                self.running2 = false;
 10525
 10526                try
 10527                {
 10528                    if (self.awaiter2.GetResult())
 10529                    {
 10530                        self.hasCurrent2 = true;
 10531                        self.current2 = self.enumerator2.Current;
 10532                        goto SUCCESS;
 10533                    }
 10534                    else
 10535                    {
 10536                        self.running2 = true; // as complete, no more call MoveNextAsync.
 10537                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10538                        {
 10539                            goto COMPLETE;
 10540                        }
 10541                        return;
 10542                    }
 10543                }
 10544                catch (Exception ex)
 10545                {
 10546                    self.running2 = true; // as complete, no more call MoveNextAsync.
 10547                    self.completedCount = CompleteCount;
 10548                    self.completionSource.TrySetException(ex);
 10549                    return;
 10550                }
 10551
 10552                SUCCESS:
 10553                if (!self.TrySetResult())
 10554                {
 10555                    if (self.syncRunning) return;
 10556                    self.running2 = true; // as complete, no more call MoveNextAsync.
 10557                    try
 10558                    {
 10559                        self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter();
 10560                    }
 10561                    catch (Exception ex)
 10562                    {
 10563                        self.completedCount = CompleteCount;
 10564                        self.completionSource.TrySetException(ex);
 10565                        return;
 10566                    }
 10567
 10568                    self.awaiter2.SourceOnCompleted(Completed2Delegate, self);
 10569                }
 10570                return;
 10571                COMPLETE:
 10572                self.completionSource.TrySetResult(false);
 10573                return;
 10574            }
 10575
 10576            static void Completed3(object state)
 10577            {
 10578                var self = (_CombineLatest)state;
 10579                self.running3 = false;
 10580
 10581                try
 10582                {
 10583                    if (self.awaiter3.GetResult())
 10584                    {
 10585                        self.hasCurrent3 = true;
 10586                        self.current3 = self.enumerator3.Current;
 10587                        goto SUCCESS;
 10588                    }
 10589                    else
 10590                    {
 10591                        self.running3 = true; // as complete, no more call MoveNextAsync.
 10592                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10593                        {
 10594                            goto COMPLETE;
 10595                        }
 10596                        return;
 10597                    }
 10598                }
 10599                catch (Exception ex)
 10600                {
 10601                    self.running3 = true; // as complete, no more call MoveNextAsync.
 10602                    self.completedCount = CompleteCount;
 10603                    self.completionSource.TrySetException(ex);
 10604                    return;
 10605                }
 10606
 10607                SUCCESS:
 10608                if (!self.TrySetResult())
 10609                {
 10610                    if (self.syncRunning) return;
 10611                    self.running3 = true; // as complete, no more call MoveNextAsync.
 10612                    try
 10613                    {
 10614                        self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter();
 10615                    }
 10616                    catch (Exception ex)
 10617                    {
 10618                        self.completedCount = CompleteCount;
 10619                        self.completionSource.TrySetException(ex);
 10620                        return;
 10621                    }
 10622
 10623                    self.awaiter3.SourceOnCompleted(Completed3Delegate, self);
 10624                }
 10625                return;
 10626                COMPLETE:
 10627                self.completionSource.TrySetResult(false);
 10628                return;
 10629            }
 10630
 10631            static void Completed4(object state)
 10632            {
 10633                var self = (_CombineLatest)state;
 10634                self.running4 = false;
 10635
 10636                try
 10637                {
 10638                    if (self.awaiter4.GetResult())
 10639                    {
 10640                        self.hasCurrent4 = true;
 10641                        self.current4 = self.enumerator4.Current;
 10642                        goto SUCCESS;
 10643                    }
 10644                    else
 10645                    {
 10646                        self.running4 = true; // as complete, no more call MoveNextAsync.
 10647                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10648                        {
 10649                            goto COMPLETE;
 10650                        }
 10651                        return;
 10652                    }
 10653                }
 10654                catch (Exception ex)
 10655                {
 10656                    self.running4 = true; // as complete, no more call MoveNextAsync.
 10657                    self.completedCount = CompleteCount;
 10658                    self.completionSource.TrySetException(ex);
 10659                    return;
 10660                }
 10661
 10662                SUCCESS:
 10663                if (!self.TrySetResult())
 10664                {
 10665                    if (self.syncRunning) return;
 10666                    self.running4 = true; // as complete, no more call MoveNextAsync.
 10667                    try
 10668                    {
 10669                        self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter();
 10670                    }
 10671                    catch (Exception ex)
 10672                    {
 10673                        self.completedCount = CompleteCount;
 10674                        self.completionSource.TrySetException(ex);
 10675                        return;
 10676                    }
 10677
 10678                    self.awaiter4.SourceOnCompleted(Completed4Delegate, self);
 10679                }
 10680                return;
 10681                COMPLETE:
 10682                self.completionSource.TrySetResult(false);
 10683                return;
 10684            }
 10685
 10686            static void Completed5(object state)
 10687            {
 10688                var self = (_CombineLatest)state;
 10689                self.running5 = false;
 10690
 10691                try
 10692                {
 10693                    if (self.awaiter5.GetResult())
 10694                    {
 10695                        self.hasCurrent5 = true;
 10696                        self.current5 = self.enumerator5.Current;
 10697                        goto SUCCESS;
 10698                    }
 10699                    else
 10700                    {
 10701                        self.running5 = true; // as complete, no more call MoveNextAsync.
 10702                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10703                        {
 10704                            goto COMPLETE;
 10705                        }
 10706                        return;
 10707                    }
 10708                }
 10709                catch (Exception ex)
 10710                {
 10711                    self.running5 = true; // as complete, no more call MoveNextAsync.
 10712                    self.completedCount = CompleteCount;
 10713                    self.completionSource.TrySetException(ex);
 10714                    return;
 10715                }
 10716
 10717                SUCCESS:
 10718                if (!self.TrySetResult())
 10719                {
 10720                    if (self.syncRunning) return;
 10721                    self.running5 = true; // as complete, no more call MoveNextAsync.
 10722                    try
 10723                    {
 10724                        self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter();
 10725                    }
 10726                    catch (Exception ex)
 10727                    {
 10728                        self.completedCount = CompleteCount;
 10729                        self.completionSource.TrySetException(ex);
 10730                        return;
 10731                    }
 10732
 10733                    self.awaiter5.SourceOnCompleted(Completed5Delegate, self);
 10734                }
 10735                return;
 10736                COMPLETE:
 10737                self.completionSource.TrySetResult(false);
 10738                return;
 10739            }
 10740
 10741            static void Completed6(object state)
 10742            {
 10743                var self = (_CombineLatest)state;
 10744                self.running6 = false;
 10745
 10746                try
 10747                {
 10748                    if (self.awaiter6.GetResult())
 10749                    {
 10750                        self.hasCurrent6 = true;
 10751                        self.current6 = self.enumerator6.Current;
 10752                        goto SUCCESS;
 10753                    }
 10754                    else
 10755                    {
 10756                        self.running6 = true; // as complete, no more call MoveNextAsync.
 10757                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10758                        {
 10759                            goto COMPLETE;
 10760                        }
 10761                        return;
 10762                    }
 10763                }
 10764                catch (Exception ex)
 10765                {
 10766                    self.running6 = true; // as complete, no more call MoveNextAsync.
 10767                    self.completedCount = CompleteCount;
 10768                    self.completionSource.TrySetException(ex);
 10769                    return;
 10770                }
 10771
 10772                SUCCESS:
 10773                if (!self.TrySetResult())
 10774                {
 10775                    if (self.syncRunning) return;
 10776                    self.running6 = true; // as complete, no more call MoveNextAsync.
 10777                    try
 10778                    {
 10779                        self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter();
 10780                    }
 10781                    catch (Exception ex)
 10782                    {
 10783                        self.completedCount = CompleteCount;
 10784                        self.completionSource.TrySetException(ex);
 10785                        return;
 10786                    }
 10787
 10788                    self.awaiter6.SourceOnCompleted(Completed6Delegate, self);
 10789                }
 10790                return;
 10791                COMPLETE:
 10792                self.completionSource.TrySetResult(false);
 10793                return;
 10794            }
 10795
 10796            static void Completed7(object state)
 10797            {
 10798                var self = (_CombineLatest)state;
 10799                self.running7 = false;
 10800
 10801                try
 10802                {
 10803                    if (self.awaiter7.GetResult())
 10804                    {
 10805                        self.hasCurrent7 = true;
 10806                        self.current7 = self.enumerator7.Current;
 10807                        goto SUCCESS;
 10808                    }
 10809                    else
 10810                    {
 10811                        self.running7 = true; // as complete, no more call MoveNextAsync.
 10812                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10813                        {
 10814                            goto COMPLETE;
 10815                        }
 10816                        return;
 10817                    }
 10818                }
 10819                catch (Exception ex)
 10820                {
 10821                    self.running7 = true; // as complete, no more call MoveNextAsync.
 10822                    self.completedCount = CompleteCount;
 10823                    self.completionSource.TrySetException(ex);
 10824                    return;
 10825                }
 10826
 10827                SUCCESS:
 10828                if (!self.TrySetResult())
 10829                {
 10830                    if (self.syncRunning) return;
 10831                    self.running7 = true; // as complete, no more call MoveNextAsync.
 10832                    try
 10833                    {
 10834                        self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter();
 10835                    }
 10836                    catch (Exception ex)
 10837                    {
 10838                        self.completedCount = CompleteCount;
 10839                        self.completionSource.TrySetException(ex);
 10840                        return;
 10841                    }
 10842
 10843                    self.awaiter7.SourceOnCompleted(Completed7Delegate, self);
 10844                }
 10845                return;
 10846                COMPLETE:
 10847                self.completionSource.TrySetResult(false);
 10848                return;
 10849            }
 10850
 10851            static void Completed8(object state)
 10852            {
 10853                var self = (_CombineLatest)state;
 10854                self.running8 = false;
 10855
 10856                try
 10857                {
 10858                    if (self.awaiter8.GetResult())
 10859                    {
 10860                        self.hasCurrent8 = true;
 10861                        self.current8 = self.enumerator8.Current;
 10862                        goto SUCCESS;
 10863                    }
 10864                    else
 10865                    {
 10866                        self.running8 = true; // as complete, no more call MoveNextAsync.
 10867                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10868                        {
 10869                            goto COMPLETE;
 10870                        }
 10871                        return;
 10872                    }
 10873                }
 10874                catch (Exception ex)
 10875                {
 10876                    self.running8 = true; // as complete, no more call MoveNextAsync.
 10877                    self.completedCount = CompleteCount;
 10878                    self.completionSource.TrySetException(ex);
 10879                    return;
 10880                }
 10881
 10882                SUCCESS:
 10883                if (!self.TrySetResult())
 10884                {
 10885                    if (self.syncRunning) return;
 10886                    self.running8 = true; // as complete, no more call MoveNextAsync.
 10887                    try
 10888                    {
 10889                        self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter();
 10890                    }
 10891                    catch (Exception ex)
 10892                    {
 10893                        self.completedCount = CompleteCount;
 10894                        self.completionSource.TrySetException(ex);
 10895                        return;
 10896                    }
 10897
 10898                    self.awaiter8.SourceOnCompleted(Completed8Delegate, self);
 10899                }
 10900                return;
 10901                COMPLETE:
 10902                self.completionSource.TrySetResult(false);
 10903                return;
 10904            }
 10905
 10906            static void Completed9(object state)
 10907            {
 10908                var self = (_CombineLatest)state;
 10909                self.running9 = false;
 10910
 10911                try
 10912                {
 10913                    if (self.awaiter9.GetResult())
 10914                    {
 10915                        self.hasCurrent9 = true;
 10916                        self.current9 = self.enumerator9.Current;
 10917                        goto SUCCESS;
 10918                    }
 10919                    else
 10920                    {
 10921                        self.running9 = true; // as complete, no more call MoveNextAsync.
 10922                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10923                        {
 10924                            goto COMPLETE;
 10925                        }
 10926                        return;
 10927                    }
 10928                }
 10929                catch (Exception ex)
 10930                {
 10931                    self.running9 = true; // as complete, no more call MoveNextAsync.
 10932                    self.completedCount = CompleteCount;
 10933                    self.completionSource.TrySetException(ex);
 10934                    return;
 10935                }
 10936
 10937                SUCCESS:
 10938                if (!self.TrySetResult())
 10939                {
 10940                    if (self.syncRunning) return;
 10941                    self.running9 = true; // as complete, no more call MoveNextAsync.
 10942                    try
 10943                    {
 10944                        self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter();
 10945                    }
 10946                    catch (Exception ex)
 10947                    {
 10948                        self.completedCount = CompleteCount;
 10949                        self.completionSource.TrySetException(ex);
 10950                        return;
 10951                    }
 10952
 10953                    self.awaiter9.SourceOnCompleted(Completed9Delegate, self);
 10954                }
 10955                return;
 10956                COMPLETE:
 10957                self.completionSource.TrySetResult(false);
 10958                return;
 10959            }
 10960
 10961            static void Completed10(object state)
 10962            {
 10963                var self = (_CombineLatest)state;
 10964                self.running10 = false;
 10965
 10966                try
 10967                {
 10968                    if (self.awaiter10.GetResult())
 10969                    {
 10970                        self.hasCurrent10 = true;
 10971                        self.current10 = self.enumerator10.Current;
 10972                        goto SUCCESS;
 10973                    }
 10974                    else
 10975                    {
 10976                        self.running10 = true; // as complete, no more call MoveNextAsync.
 10977                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 10978                        {
 10979                            goto COMPLETE;
 10980                        }
 10981                        return;
 10982                    }
 10983                }
 10984                catch (Exception ex)
 10985                {
 10986                    self.running10 = true; // as complete, no more call MoveNextAsync.
 10987                    self.completedCount = CompleteCount;
 10988                    self.completionSource.TrySetException(ex);
 10989                    return;
 10990                }
 10991
 10992                SUCCESS:
 10993                if (!self.TrySetResult())
 10994                {
 10995                    if (self.syncRunning) return;
 10996                    self.running10 = true; // as complete, no more call MoveNextAsync.
 10997                    try
 10998                    {
 10999                        self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter();
 11000                    }
 11001                    catch (Exception ex)
 11002                    {
 11003                        self.completedCount = CompleteCount;
 11004                        self.completionSource.TrySetException(ex);
 11005                        return;
 11006                    }
 11007
 11008                    self.awaiter10.SourceOnCompleted(Completed10Delegate, self);
 11009                }
 11010                return;
 11011                COMPLETE:
 11012                self.completionSource.TrySetResult(false);
 11013                return;
 11014            }
 11015
 11016            static void Completed11(object state)
 11017            {
 11018                var self = (_CombineLatest)state;
 11019                self.running11 = false;
 11020
 11021                try
 11022                {
 11023                    if (self.awaiter11.GetResult())
 11024                    {
 11025                        self.hasCurrent11 = true;
 11026                        self.current11 = self.enumerator11.Current;
 11027                        goto SUCCESS;
 11028                    }
 11029                    else
 11030                    {
 11031                        self.running11 = true; // as complete, no more call MoveNextAsync.
 11032                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 11033                        {
 11034                            goto COMPLETE;
 11035                        }
 11036                        return;
 11037                    }
 11038                }
 11039                catch (Exception ex)
 11040                {
 11041                    self.running11 = true; // as complete, no more call MoveNextAsync.
 11042                    self.completedCount = CompleteCount;
 11043                    self.completionSource.TrySetException(ex);
 11044                    return;
 11045                }
 11046
 11047                SUCCESS:
 11048                if (!self.TrySetResult())
 11049                {
 11050                    if (self.syncRunning) return;
 11051                    self.running11 = true; // as complete, no more call MoveNextAsync.
 11052                    try
 11053                    {
 11054                        self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter();
 11055                    }
 11056                    catch (Exception ex)
 11057                    {
 11058                        self.completedCount = CompleteCount;
 11059                        self.completionSource.TrySetException(ex);
 11060                        return;
 11061                    }
 11062
 11063                    self.awaiter11.SourceOnCompleted(Completed11Delegate, self);
 11064                }
 11065                return;
 11066                COMPLETE:
 11067                self.completionSource.TrySetResult(false);
 11068                return;
 11069            }
 11070
 11071            static void Completed12(object state)
 11072            {
 11073                var self = (_CombineLatest)state;
 11074                self.running12 = false;
 11075
 11076                try
 11077                {
 11078                    if (self.awaiter12.GetResult())
 11079                    {
 11080                        self.hasCurrent12 = true;
 11081                        self.current12 = self.enumerator12.Current;
 11082                        goto SUCCESS;
 11083                    }
 11084                    else
 11085                    {
 11086                        self.running12 = true; // as complete, no more call MoveNextAsync.
 11087                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 11088                        {
 11089                            goto COMPLETE;
 11090                        }
 11091                        return;
 11092                    }
 11093                }
 11094                catch (Exception ex)
 11095                {
 11096                    self.running12 = true; // as complete, no more call MoveNextAsync.
 11097                    self.completedCount = CompleteCount;
 11098                    self.completionSource.TrySetException(ex);
 11099                    return;
 11100                }
 11101
 11102                SUCCESS:
 11103                if (!self.TrySetResult())
 11104                {
 11105                    if (self.syncRunning) return;
 11106                    self.running12 = true; // as complete, no more call MoveNextAsync.
 11107                    try
 11108                    {
 11109                        self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter();
 11110                    }
 11111                    catch (Exception ex)
 11112                    {
 11113                        self.completedCount = CompleteCount;
 11114                        self.completionSource.TrySetException(ex);
 11115                        return;
 11116                    }
 11117
 11118                    self.awaiter12.SourceOnCompleted(Completed12Delegate, self);
 11119                }
 11120                return;
 11121                COMPLETE:
 11122                self.completionSource.TrySetResult(false);
 11123                return;
 11124            }
 11125
 11126            static void Completed13(object state)
 11127            {
 11128                var self = (_CombineLatest)state;
 11129                self.running13 = false;
 11130
 11131                try
 11132                {
 11133                    if (self.awaiter13.GetResult())
 11134                    {
 11135                        self.hasCurrent13 = true;
 11136                        self.current13 = self.enumerator13.Current;
 11137                        goto SUCCESS;
 11138                    }
 11139                    else
 11140                    {
 11141                        self.running13 = true; // as complete, no more call MoveNextAsync.
 11142                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 11143                        {
 11144                            goto COMPLETE;
 11145                        }
 11146                        return;
 11147                    }
 11148                }
 11149                catch (Exception ex)
 11150                {
 11151                    self.running13 = true; // as complete, no more call MoveNextAsync.
 11152                    self.completedCount = CompleteCount;
 11153                    self.completionSource.TrySetException(ex);
 11154                    return;
 11155                }
 11156
 11157                SUCCESS:
 11158                if (!self.TrySetResult())
 11159                {
 11160                    if (self.syncRunning) return;
 11161                    self.running13 = true; // as complete, no more call MoveNextAsync.
 11162                    try
 11163                    {
 11164                        self.awaiter13 = self.enumerator13.MoveNextAsync().GetAwaiter();
 11165                    }
 11166                    catch (Exception ex)
 11167                    {
 11168                        self.completedCount = CompleteCount;
 11169                        self.completionSource.TrySetException(ex);
 11170                        return;
 11171                    }
 11172
 11173                    self.awaiter13.SourceOnCompleted(Completed13Delegate, self);
 11174                }
 11175                return;
 11176                COMPLETE:
 11177                self.completionSource.TrySetResult(false);
 11178                return;
 11179            }
 11180
 11181            static void Completed14(object state)
 11182            {
 11183                var self = (_CombineLatest)state;
 11184                self.running14 = false;
 11185
 11186                try
 11187                {
 11188                    if (self.awaiter14.GetResult())
 11189                    {
 11190                        self.hasCurrent14 = true;
 11191                        self.current14 = self.enumerator14.Current;
 11192                        goto SUCCESS;
 11193                    }
 11194                    else
 11195                    {
 11196                        self.running14 = true; // as complete, no more call MoveNextAsync.
 11197                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 11198                        {
 11199                            goto COMPLETE;
 11200                        }
 11201                        return;
 11202                    }
 11203                }
 11204                catch (Exception ex)
 11205                {
 11206                    self.running14 = true; // as complete, no more call MoveNextAsync.
 11207                    self.completedCount = CompleteCount;
 11208                    self.completionSource.TrySetException(ex);
 11209                    return;
 11210                }
 11211
 11212                SUCCESS:
 11213                if (!self.TrySetResult())
 11214                {
 11215                    if (self.syncRunning) return;
 11216                    self.running14 = true; // as complete, no more call MoveNextAsync.
 11217                    try
 11218                    {
 11219                        self.awaiter14 = self.enumerator14.MoveNextAsync().GetAwaiter();
 11220                    }
 11221                    catch (Exception ex)
 11222                    {
 11223                        self.completedCount = CompleteCount;
 11224                        self.completionSource.TrySetException(ex);
 11225                        return;
 11226                    }
 11227
 11228                    self.awaiter14.SourceOnCompleted(Completed14Delegate, self);
 11229                }
 11230                return;
 11231                COMPLETE:
 11232                self.completionSource.TrySetResult(false);
 11233                return;
 11234            }
 11235
 11236            static void Completed15(object state)
 11237            {
 11238                var self = (_CombineLatest)state;
 11239                self.running15 = false;
 11240
 11241                try
 11242                {
 11243                    if (self.awaiter15.GetResult())
 11244                    {
 11245                        self.hasCurrent15 = true;
 11246                        self.current15 = self.enumerator15.Current;
 11247                        goto SUCCESS;
 11248                    }
 11249                    else
 11250                    {
 11251                        self.running15 = true; // as complete, no more call MoveNextAsync.
 11252                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
 11253                        {
 11254                            goto COMPLETE;
 11255                        }
 11256                        return;
 11257                    }
 11258                }
 11259                catch (Exception ex)
 11260                {
 11261                    self.running15 = true; // as complete, no more call MoveNextAsync.
 11262                    self.completedCount = CompleteCount;
 11263                    self.completionSource.TrySetException(ex);
 11264                    return;
 11265                }
 11266
 11267                SUCCESS:
 11268                if (!self.TrySetResult())
 11269                {
 11270                    if (self.syncRunning) return;
 11271                    self.running15 = true; // as complete, no more call MoveNextAsync.
 11272                    try
 11273                    {
 11274                        self.awaiter15 = self.enumerator15.MoveNextAsync().GetAwaiter();
 11275                    }
 11276                    catch (Exception ex)
 11277                    {
 11278                        self.completedCount = CompleteCount;
 11279                        self.completionSource.TrySetException(ex);
 11280                        return;
 11281                    }
 11282
 11283                    self.awaiter15.SourceOnCompleted(Completed15Delegate, self);
 11284                }
 11285                return;
 11286                COMPLETE:
 11287                self.completionSource.TrySetResult(false);
 11288                return;
 11289            }
 11290
 11291            bool TrySetResult()
 11292            {
 11293                if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent
 11294                {
 11295                    result = resultSelector(current1, current2, current3, current4, current5, current6, current7, curren
 11296                    completionSource.TrySetResult(true);
 11297                    return true;
 11298                }
 11299                else
 11300                {
 11301                    return false;
 11302                }
 11303            }
 11304
 11305            public async UniTask DisposeAsync()
 11306            {
 11307                TaskTracker.RemoveTracking(this);
 11308                if (enumerator1 != null)
 11309                {
 11310                    await enumerator1.DisposeAsync();
 11311                }
 11312                if (enumerator2 != null)
 11313                {
 11314                    await enumerator2.DisposeAsync();
 11315                }
 11316                if (enumerator3 != null)
 11317                {
 11318                    await enumerator3.DisposeAsync();
 11319                }
 11320                if (enumerator4 != null)
 11321                {
 11322                    await enumerator4.DisposeAsync();
 11323                }
 11324                if (enumerator5 != null)
 11325                {
 11326                    await enumerator5.DisposeAsync();
 11327                }
 11328                if (enumerator6 != null)
 11329                {
 11330                    await enumerator6.DisposeAsync();
 11331                }
 11332                if (enumerator7 != null)
 11333                {
 11334                    await enumerator7.DisposeAsync();
 11335                }
 11336                if (enumerator8 != null)
 11337                {
 11338                    await enumerator8.DisposeAsync();
 11339                }
 11340                if (enumerator9 != null)
 11341                {
 11342                    await enumerator9.DisposeAsync();
 11343                }
 11344                if (enumerator10 != null)
 11345                {
 11346                    await enumerator10.DisposeAsync();
 11347                }
 11348                if (enumerator11 != null)
 11349                {
 11350                    await enumerator11.DisposeAsync();
 11351                }
 11352                if (enumerator12 != null)
 11353                {
 11354                    await enumerator12.DisposeAsync();
 11355                }
 11356                if (enumerator13 != null)
 11357                {
 11358                    await enumerator13.DisposeAsync();
 11359                }
 11360                if (enumerator14 != null)
 11361                {
 11362                    await enumerator14.DisposeAsync();
 11363                }
 11364                if (enumerator15 != null)
 11365                {
 11366                    await enumerator15.DisposeAsync();
 11367                }
 11368            }
 11369        }
 11370    }
 11371
 11372}

Methods/Properties

CombineLatest(Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T1], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T2], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T3], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T4], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T5], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T6], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T7], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T8], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T9], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T10], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T11], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T12], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T13], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T14], System.Func[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult])
GetAsyncEnumerator(System.Threading.CancellationToken)
_CombineLatest()
_CombineLatest(Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T1], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T2], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T3], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T4], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T5], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T6], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T7], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T8], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T9], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T10], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T11], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T12], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T13], Cysharp.Threading.Tasks.IUniTaskAsyncEnumerable[T14], System.Func[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult], System.Threading.CancellationToken)
Current()
MoveNextAsync()
Completed1(System.Object)
Completed2(System.Object)
Completed3(System.Object)
Completed4(System.Object)
Completed5(System.Object)
Completed6(System.Object)
Completed7(System.Object)
Completed8(System.Object)
Completed9(System.Object)
Completed10(System.Object)
Completed11(System.Object)
Completed12(System.Object)
Completed13(System.Object)
Completed14(System.Object)
TrySetResult()
DisposeAsync()